HDU3519_Lucky Coins Sequence_推公式_矩阵加速

这道题真好，体现了思想的灵活性。要3个连续状态以上嘛，好，那我就求出

只有1~2个状态的数量，最后总数减去即可。美妙，完结。

/*
*State:    3519    0MS    256K    2354 B    
*题目大意：
*        给定n个硬币，硬币有两种状态0或1，可以翻转，总共有2^n种
*        状态，规定如果有连续3个硬币的状态一样，即是特殊串。要求
*        特殊串的个数。
*解题思路：
*        已知总数目，那么可以用相反的思想求出该串状态不含有3个
*        连续一样的数目，然后用总数去减。
*        长度为 n 的 01 串一共有 2^n 种不同的排列方法 ,
*        设 f(n) 为长度是 n 的不包含连续 3 个或以上相同的 1 或 0 的 01 串 ,
*        则 f(1)=2,f(2)=4,f(3)=6,f(4)=10
*        当 n>4 的时候 , 分情况考虑 :
*            1、   如果是以 00 或者 11 结尾 , 则分别有 f(n-2)/2 种情况 , 
*            加起来就是 f(n-2) 种 .
*            2、   如果是以 01 或者 10 结尾 , 则第 n 个字符要和第 n-1 个
*            字符不一样 , 那么分别有 f(n-1)/2 种 , 加起来就是 f(n-1)
*        则统计起来就是 f(n)=f(n-1)+f(n-2)。之后构造矩阵即可。
*解题感想：
*        这道题目是搜题解的，表示做法其实也就一般，关键看能否想到用反推，还有
*        公式。
*        由于最后有一步减法，由于是模的关系，有可能结果为负，注意模减法的特殊性。
*        由于这个错误贡献了两个wa,还查了半个小时不止。最后还好乱给出测试数据了嘻。
*/

#include <iostream>
#include <cmath>
#define maxn 3

using namespace std;

struct Mat
{
    int m, n;
    int d[maxn][maxn];
    void init(int m, int n) 
    {
        this->m = m;
        this->n = n;
        memset(d, 0, sizeof(d));
    }
    void initE(int size)                              //生成单位阵
    {
        m = n = size;
        for(int i = 0; i < n; i ++)
        {
            for(int j = 0; j < n; j ++)
            {
                d[i][j] = i==j;
            }
        }
    }
    Mat operator * (const Mat & mat) const
    {
        static Mat res;
        res.init(m, mat.n);
        for(int i = 0; i < res.m; i ++)
        {
            for(int k = 0; k < n; k ++)
            {
                if(d[i][k]==0)    continue;
                for(int j = 0; j < res.n; j ++)
                {
                    res.d[i][j] += d[i][k] * mat.d[k][j];
                }
            }
        }
        return res;
    }
    Mat mul_mod(const Mat & mat, int mod) const
    {
        static Mat res;
        res.init(m, mat.n);
        for(int i = 0; i < res.m; i ++)
        {
            for(int k = 0; k < n; k ++)
            {
                if(d[i][k]==0)    continue;
                for(int j = 0; j < res.n; j ++)
                {
                    res.d[i][j]=(res.d[i][j]+d[i][k]*mat.d[k][j]) % mod;
                }
            }
        }
        return res;
    }
    void pow_mod(int k, int mod)                      //this = this^k % mod;
    {
        static Mat a;
        a = *this;
        for(this->initE(n); k; k>>=1, a=a.mul_mod(a, mod))
            if(k&1)    *this=this->mul_mod(a, mod);
    }
    void view_arr()
    {
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
                cout << d[i][j] << " ";
            cout << endl;
        }
    }
};

int mod_pow(int a,int k,int m) 
{
    static int r;
    for(r=1;k;k>>=1,a=a*a%m)    if(k&1)    r=r*a%m;
    return r;
}

int main(void)
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    int n, mod;
    
    mod = 10007;

    while(scanf("%d", &n) == 1)
    {
        Mat a;
        a.init(2, 2);
        a.d[0][0] = a.d[0][1] = a.d[1][0] = 1;
        a.d[1][1] = 0;
        if(n == 1 || n == 2)
        {
            printf("0\n");
            continue;
        }
        a.pow_mod(n - 2, mod);
        int tol = mod_pow(2, n, mod);
        int fn = (a.d[0][0] * 4 + a.d[0][1] * 2) % mod;
        //cout << "fn: " << fn << endl;
        //cout << tol << endl;0
        printf("%d\n", ((tol - fn) % mod + mod) % mod);
    }
    return 0;
}