H - 3的幂的和（快速幂）

求：3^0 + 3^1 +...+ 3^(N) mod 1000000007

Input
输入一个数N(0 <= N <= 10^9)
Output
输出：计算结果
Sample Input

3

Sample Output

40

要用到的知识：

**逆元：
若对于数字A,C 存在X，使A * X = 1 (mod C) ,那么称X为 A 对C的乘法逆元。
理论依据:
F / A mod C = ?
如果存在 A*X = 1 (mod C)
那么2边同时乘起来,得到 F * X = ? (mod C)**

成立条件

(1) 模方程 A * X = 1(mod C) 存在解

(2) A | F (F % A == 0)

若ax=1 mod f 则称a关于模f的乘法逆元为x。也可表示为ax≡1(mod f)。

　　当a与f互素时，a关于模f的乘法逆元有唯一解。如果不互素，则无解。如果f为素数，则从1到f-1的任意数都与f互素，即在1到f-1之间都恰好有一个关于模f的乘法逆元
a*b

快速乘法的基本思想 ，是二进制和乘法分配律的结合，（不由得想起浮点数不满足结合律，严重吐槽！！！╮(╯-╰)╭），比如说，13 ==（1101）2 ，4*13等于4*（1101）2 ，用分配律展开得到4*13 == 4*（1000+100+1）2，我们不难观察出，快速幂可以通过判断当前的位（bit）是1还是0，推断出是否需要做求和操作，每次移动到下一位（bit）时，就对ans进行*2操作，等待是否求和。由于除以2和位移操作是等效的，因此这也可以看作是二分思想的应用，这种算法将b进行二分从而减少了不必要的运算，时间复杂度是log（n）。

a^b

快速幂其实可以看作是快速乘法的特例，在快速幂中，我们不再对ans进行2操作，因为在a^b中b的意义已经从乘数变成了指数，但是我们可以仍然把b写成二进制，举例说明：此时，我们将4*13改为4^13，13=（1101）2 ，二进制13写开我们得到（1000+100+1），注意，这里的所有二进制是指数，指数的相加意味着底数相乘，因此有4^13 == 48 * 44 * 41。再注意到指数之间的2倍关系，我们就可以用很少的几个变量，完成这一算法。这样，我们就将原本用循环需要O(n)的算法，改进为O（logN）的算法。*

按照惯例，给出尽可能简洁高效的代码实现 （以下所有int都可用long long 代替）

首先，给出快速乘法的实现：

1 //快速乘法 
2 int qmul(int a,int b){// 根据数据范围可选择long long 
3     int ans=0;
4     while(b){
5         if( b&1)ans+=a;//按位与完成位数为1的判断
6         b>>=1;a<<=1;//位运算代替/2和*2
7     }
8     return ans;
9 }

如果涉及到快速乘法取模，则需要进行一些微小改动

1 //快速乘法取模 
2 int qmul_mod(int a,int b,int mod){
3     int ans=0;
4     while(b){
5         if((b%=mod)&1)ans+=a%=mod;//这里需要b%=mod 以及a%=mod 
6         b>>=1;a<<=1;
7     }
8     return ans%mod;  //ans也需要对mod取模 
9 }

接下来是快速幂的实现：

1 //快速幂 a^b 
 2 int qpow(int a,int b){
 3     if(a==0)return 0;//这是个坑，校赛被坑过，很多网上的实现都没写这一点
 4     int ans=1;
 5     while(b){
 6         if(b&1)ans*=a;//和快速乘法的区别
 7         b>>=1;a*=a;//区别，同上
 8     }
 9     return ans;
10 } 

以及含有取模的快速幂：

int qpow_mod(int a,int b,int mod){
    if(a==0)return 0;
    int ans=1;
    while(b){
        if(b&1)ans=(ans%mod)*(a%mod);//如果确定数据不会爆的话，可写成 ans*=a%=mod;
        b>>=1;a*=a%=mod;//等价于a=(a%mod)*(a%mod)，且将一个模运算通过赋值代替，提高了效率
    }
    return ans%mod;//数据不会爆的话，这里的%运算会等价于第5中不断重复的 ans%mod
}

如果我们对于性能还有更进一步的要求，那么也就是减少取模运算了，那么我们需要确定数据范围不会爆掉

在这样的前提下，我们可以只用原先1/4的取模运算量完成快速幂

int qpow_mod(int a,int b,int mod){
    if(!a)return 0;
    int ans=1;
    while(b){
        if(b&1)ans*=a%=mod;//这里的模运算只有一个
        b>>=1;a*=a;//这里的模运算没有了
    }
    return ans%mod;
}

完整代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
#define MOD 1000000007
typedef long long LL;
LL quick_mul(LL x,LL n){
    LL res=1;
    while(n){
    if(n&1)
        res=(res*x)%MOD;
    x=x*x%MOD;
    n/=2;
    }
    return res;
}
int main()
{
    LL n,sum;
    scanf("%I64d",&n);
    sum=(quick_mul(3,n+1)-1)*500000004%MOD;//运用到了等比数列求和公式，等价于（3^(n+1）-1）/2,2对1000000007的逆元为500000004。
    printf("%I64d",sum);
    return 0;
}

参考链接：http://www.cnblogs.com/luruiyuan/p/5570756.html