hrbust 1401 九连环（矩阵快速幂）

九连环

Time Limit: 1000 MS Memory Limit: 65536 K Total Submit: 65(37 users) Total Accepted: 34(31 users) Rating:  Special Judge: No

Description

相信大家都玩过九连环的游戏 ，九连环的规则是 ： 1第一个环可以在任何时候挂到柄上或者从柄上摘下 2在任何时候，你只能操作一个环 3如果前k-2个环都没有在柄上，并且第k-1个环在柄上，这时如果第k个环在柄上的话，可以把它摘下来，如果它不在柄上，可以把它挂上去

Input

给定一个数n，n不大于10的8次方，你的任务是输出从柄上摘下n个环需要的最小操作次数，测试数据不超过100组。

Output

输出1行，因为结果非常大，所以你需要输出结果对素数10007的余数。

Sample Input

1 2 9

Sample Output

1 2 341

思路：每一个翻转必须他前面个那个向上，前面k-2个必须全部向下。

0表示上，1表示下，假设6个环初始是000000，首先肯定要将最后一个朝下，前提是变成111100，这里有个子问题，把前四个朝

下，是f(4), 可以想到可能有这么一个公式f[n] = f[n-2]+X, 这个X是每次要把111100全部向下所需的步骤，手动模拟几个可以发现规律

每种这样操作需要2^(len-1)次。

所以公式就是f[n] = f[n-2]+2^(n-1),然后直接构造矩阵快速幂就行了。

代码:

#include
#include
#include
using namespace std;
const int mod = 1e4+7;
struct node
{
    int s[3][3];
};

node mul(node a, node b)
{
    node t;
    memset(t.s, 0, sizeof(t.s));
    for(int i = 0; i < 3; i++)
        for(int j = 0; j < 3; j++)
            for(int k = 0; k < 3; k++)
                t.s[i][j] = (t.s[i][j]+a.s[i][k]*b.s[k][j])%mod;
    return t;
}

node mt_pow(node p, int k)
{
    node q;
    memset(q.s, 0, sizeof(q.s));
    for(int i = 0; i < 3; i++)
        q.s[i][i] = 1;
    while(k)
    {
        if(k%2) q = mul(q, p);
        p = mul(p, p);
        k /= 2;
    }
    return q;
}

int main(void)
{
    int n;
    while(cin >> n)
    {
        node base;
        memset(base.s, 0, sizeof(base.s));
        base.s[0][1] = 1, base.s[0][2] = 2;
        base.s[1][0] = 1, base.s[2][2] = 2;
        if(n == 1) puts("1");
        else if(n == 2) puts("2");
        else
        {
            node ans = mt_pow(base, n-2);
            printf("%d\n", (ans.s[0][0]*2+ans.s[0][1]+ans.s[0][2]*2)%mod);
        }
    }
    return 0;
}