qwb与神奇的序列 快速幂 非逆元 矩阵快速幂

转我自己的博客：写得贼好 http://blog.csdn.net/yo_bc/article/details/72846995

Description
qwb又遇到了一道题目：
有一个序列，初始时只有两个数x和y，之后每次操作时，在原序列的任意两个相邻数之间插入这两个数的和，得到新序列。举例说明：
初始：1 2
操作1次：1 3 2
操作2次：1 4 3 5 2
……
请问在操作n次之后，得到的序列的所有数之和是多少？
Input
多组测试数据，处理到文件结束（测试例数量<=50000）。
输入为一行三个整数x，y，n，相邻两个数之间用单个空格隔开。（0 <= x <= 1e10, 0 <= y <= 1e10, 1 < n <= 1e10）。
Output
对于每个测试例，输出一个整数，占一行，即最终序列中所有数之和。
如果和超过1e8，则输出低8位。（前导0不输出，直接理解成%1e8）
Sample Input
1 2 2
Sample Output
15

思路：规律题，首先容易推出ans[i] = ans[i-1]*3-(x+y), 再根据等比数列公式可以得到规律第n次操作的和
为：(3^n+1)/2 * (x+y);
快速幂做法需要几个注意的点：
1. 不能在求3^n的时候直接取模，之后/2%mod
2. 看到除法就想逆元是不可行的，因为2和mod不互质，所以逆元不能用。
3. 可以根据公式：(a/b)%mod = a%(b*mod)/b%mod, 所以就可以在快速幂求3^n的时候%2e8，求完之后
再/2%mod*(x+y)%mod，即可得到正确答案。

根据ans[i] = ans[i-1]*3-(x+y)还可以得到矩阵快速幂做法，

#include <bits/stdc++.h>  
#define LL long long  
using namespace std;  
const int mod = 1e8;  
LL a, b, n;  
LL quickM(LL a, LL b)  
{  
    LL ans = 1, base = a;  
    while(b)  
    {  
        if(b&1) ans = ans*base%(mod*2);  
        base = base*base%(mod*2);  
        b >>= 1;  
    }  
    return ans;  
}  
int main()  
{  
    while(~scanf("%lld %lld %lld", &a, &b, &n))  
    {  
        x = (a+b)%mod;  
        ans = (quickM(3, n)+1)/2%mod*x%mod;  
        printf("%lld\n", ans);  
    }  
    return 0;  
}  

#include <bits/stdc++.h>  
#define LL long long  
using namespace std;  
const LL mod = 1e8;  
struct node  
{  
    LL e11, e12, e13, e21, e22, e23, e31, e32, e33;  
};  
LL x, y, n;  
node multi(node a, node b)  
{  
    node ans;  
    ans.e11 = (a.e11*b.e11 + a.e12*b.e21 + a.e13*b.e31)%mod;  
    ans.e12 = (a.e11*b.e12 + a.e12*b.e22 + a.e13*b.e32)%mod;  
    ans.e13 = (a.e11*b.e13 + a.e12*b.e23 + a.e13*b.e33)%mod;  
    ans.e21 = (a.e21*b.e11 + a.e22*b.e21 + a.e23*b.e31)%mod;  
    ans.e22 = (a.e21*b.e12 + a.e22*b.e22 + a.e23*b.e32)%mod;  
    ans.e23 = (a.e21*b.e13 + a.e22*b.e23 + a.e23*b.e33)%mod;  
    ans.e31 = (a.e31*b.e11 + a.e32*b.e21 + a.e33*b.e31)%mod;  
    ans.e32 = (a.e31*b.e12 + a.e32*b.e22 + a.e33*b.e32)%mod;  
    ans.e33 = (a.e31*b.e13 + a.e32*b.e23 + a.e33*b.e33)%mod;  
    return ans;  
}  
LL quickM(LL b)  
{  
    node base, ans;  
    base.e11 = 3, base.e12 = 0, base.e13 = -1;  
    base.e21 = 0, base.e22 = 3, base.e23 = -1;  
    base.e31 = 0, base.e32 = 0, base.e33 = 1;  
    ans.e11 = 1, ans.e12 = 0, ans.e13 = 0;  
    ans.e21 = 0, ans.e22 = 1, ans.e23 = 0;  
    ans.e31 = 0, ans.e32 = 0, ans.e33 = 1;  
    while(b)  
    {  
        if(b&1) ans = multi(ans, base);  
        base = multi(base, base);  
        b >>= 1;  
    }  
    return (ans.e21*2+ans.e22*1+ans.e23+mod)%mod;  
}  
int main()  
{  
    while(~scanf("%lld %lld %lld", &x, &y, &n))  
    {  
        printf("%lld\n", (x+y)%mod*quickM(n)%mod);  
    }  
    return 0;  
}  

------------------------------优雅的分割线------------------------------  

#include <bits/stdc++.h>  
#define LL long long  
using namespace std;  
const LL mod = 1e8;  
struct node  
{  
    LL m[4][4];  
};  
LL x, y, n;  
node multi(node a, node b)  
{  
    node ans;  
    memset(ans.m, 0, sizeof ans.m);  
    for(int i = 1; i <= 3; ++i)  
        for(int j = 1; j <= 3; ++j)  
            for(int k = 1; k <= 3; ++k)  
                ans.m[i][j] = (ans.m[i][j]+a.m[i][k]*b.m[k][j])%mod;  
    return ans;  
}  
LL quickM(LL b)  
{  
    node base, ans;  
    base.m[1][1] = 3, base.m[1][2] = 0, base.m[1][3] = -1;  
    base.m[2][1] = 0, base.m[2][2] = 3, base.m[2][3] = -1;  
    base.m[3][1] = 0, base.m[3][2] = 0, base.m[3][3] = 1;  
    ans.m[1][1] = 1, ans.m[1][2] = 0, ans.m[1][3] = 0;  
    ans.m[2][1] = 0, ans.m[2][2] = 1, ans.m[2][3] = 0;  
    ans.m[3][1] = 0, ans.m[3][2] = 0, ans.m[3][3] = 1;  
    while(b)  
    {  
        if(b&1) ans = multi(ans, base);  
        base = multi(base, base);  
        b >>= 1;  
    }  
    return (ans.m[2][1]*2+ans.m[2][2]*1+ans.m[2][3]+mod)%mod;  
}  
int main()  
{  
    while(~scanf("%lld %lld %lld", &x, &y, &n))  
    {  
        printf("%lld\n", (x+y)%mod*quickM(n)%mod);  
    }  
    return 0;  
}