HDU 5868 Different Circle Permutation Burnside引理+矩阵快速幂+逆元

**题意：**有N个座位，人可以选座位，但选的座位不能相邻，且旋转不同构的坐法有几种。如4个座位有3种做法。\\( 1≤N≤1000000000 (10^9) \\).
**题解：**首先考虑座位不相邻的选法问题，如果不考虑同构，可以发现其种数是一类斐波那契函数，只不过fib(1)是1 fib(2)是3。
由于n很大，所以使用矩阵快速幂来求fib。
再者考虑到旋转同构问题，枚举旋转**i (2π/n) **度，其等价类即\\( gcd(i, n) \\)种，那么可以得$$S(n)=\frac{1}{n}\sum_{d|n}^{n}{fib(gcd(d,n))}$$
这样枚举d即可，在此之上公式还可简化成 $$S(n)=\frac{1}{n}\sum_{d|n}^{n}{fib(d)\varphi(\frac{n}{d}) }$$
而枚举因子时，注意优化，得到因子i时可以顺带得到因子n/i，不然TLE...

最后使用EXGCD求1/n的乘法逆元。

还有需要考虑一个问题，当n=1时，答案是2，而fib(1)值为1，所以需要特判一下。

这道题综合的东西还蛮多的，刚好最近都在学这些，不错的题目/.



求欧拉函数时一个地方写错了查了好久T.T

/** @Date    : 2016-11-12-19.18

  * @Author  : Lweleth (SoungEarlf@gmail.com)

  * @Link    : https://github.com/

  * @Version :

  */

#include <stdio.h>

#include <iostream>

#include <string.h>

#include <algorithm>

#include <utility>

#include <vector>

#include <map>

#include <set>

#include <string>

#include <stack>

#include <queue>

#define LL long long

#define MMF(x) memset((x),0,sizeof(x))

#define MMI(x) memset((x), INF, sizeof(x))

using namespace std;



const int INF = 0x3f3f3f3f;

const int N = 1e5+2000;

const LL mod = 1e9 + 7;







LL gcd(LL a, LL b)

{

    return b?gcd(b, a % b):a;

}



LL exgcd(LL a, LL b, LL &x, LL &y)

{

    LL d = a;

    if(a == 0 && b == 0)

        return -1;

    if(b == 0)

    {

        x = 1;

        y = 0;

    }

    else

    {

        d = exgcd(b, a % b, y, x);

        y -= (a / b) * x;

    }

    return d;

}



LL inv(LL a, LL b)

{

    LL x, y;

    LL d = exgcd(a, b, x, y);

    if(d == 1)

        return (x % b + b) % b;

    else return -1;

}



struct matrix

{

    LL mat[2][2];

    void init()

    {

        mat[0][0] = mat[1][0] = mat[0][1] = mat[1][1] = 0;

    }

};



matrix mul(matrix a, matrix b)

{

    matrix c;

    c.init();

    for(int i = 0; i < 2; i++)

        for(int j = 0; j < 2; j++)

            for(int k = 0; k < 2; k++)

            {

                c.mat[i][j] += a.mat[i][k] * b.mat[k][j];

                c.mat[i][j] %= mod;

            }

    return c;

}



matrix fpow(matrix x, LL n)

{

    matrix r;

    r.init();

    for(int i = 0; i < 2; i++)

        r.mat[i][i] = 1;

    while(n > 0)

    {

        if(n & 1)

            r = mul(r, x);

        x = mul(x, x);

        n >>= 1;

    }

    return r;

}



LL phi(int x)

{

    LL t = x;

    LL ans = x;

    for(int i = 2; i * i <= t; i++)

    {

        if(t % i == 0)

        {

            ans = ans / i * (i - 1);

            while(t % i == 0)

            {

                t /= i;

            }

        }

    }

    if(t > 1)

        ans = ans/t * (t-1);

    return ans;

}



LL fib(int x)

{

    matrix t;

    t.init();

    t.mat[0][0] = 1;

    t.mat[0][1] = 1;

    t.mat[1][0] = 1;

    matrix a;

    a = fpow(t, x-1);

    LL ans = a.mat[1][0] * 3 + a.mat[1][1];

    return ans % mod;

}

int main()

{

    LL n;

    while(~scanf("%lld", &n))

    {

        LL ans = 0;

        for(int i = 1; i * i <= n; i++)//枚举因子优化

        {

            if(n % i == 0)

            {

                ans = (ans + phi(n/i)*fib(i)) % mod;

                if(n / i != i)

                {

                    ans = (ans + phi(i)*fib(n/i)) % mod;

                }

            }

        }

        ans = ans * inv(n, mod) % mod;



        if(n == 1)

            printf("2\n");

        else

            printf("%lld\n", ans);

    }

    return 0;

}