快速幂（从幂函数到快速幂）

        一般地，y=x^α（α为有理数）的函数，即以底数x为自变量，幂α为因变量，指数为常数的函数称为幂函数。例如函数y=x^0 、y=x^1、y=x^2、y=x^(-1)（注：y=x^(-1)=1/x、y=x^0时x≠0）等都是幂函数。

问题1
编程求2*2*2*...*2
【题目描述】
编程求2*2*2*...*2。

【输入】
输入一行，只有一个整数n(1<=n<=10)

【输出】
输出只有一行，包括1个整数。

【样例输入】
5
【样例输出】
32

int n, s = 1;
cin >> n;
for (int i = 1; i <= n; i++) {
    s *= 2;
}
cout << s << endl;

样例分析
输入5，n=5
当i=1时，s=1*2=2
当i=2时，s=2*2=4
当i=3时，s=4*2=8
当i=4时，s=8*2=16
当i=5时，s=16*2=32
循环结束，s=32

---

问题2
a 的 b 次方的后两位是多少？
【题目描述】
给出两个整数 a,b，求 a 的 b 次方的后两位的值。

【输入】
一行两个整数 a,b。

【输出】
一个整数，表示 a 的 b 次方的后两位的值。

【输入样例】
2 100 
【输出样例】
76
【提示】
数据范围与提示：

对于全部数据，1≤a≤10^9,1≤b≤30 。

题目分析
因为只需要输出后两位数，所以对于a来说，百位数及其以上的数都对结果毫无意义；
只需要取a的后两位数即可(a%100)，这一方法称为“同余定理”（除法不成立）

int a, b, s = 1;
cin >> a >> b;
a = a % 100;
for (int i = 1; i <= b; i++) {
    s = s * a % 100;
}
cout << s << endl;

拓展：同余定理

同余定理：两个整数同时除以一个整数得到的余数相同，则二整数同余。记作a ≡ b(mod m)。

1. 同余定理的加法乘法应用
(a + b) % m = (a % m + b % m) % m
设 a = k1 * m + r1，b = k2 * m + r2
则 (a + b) % m = ((k1 * m + r1) + (k2 * m + r2)) % m
               = ((k1 + k2) * m + (r1 + r2)) % m
               = (r1 + r2) % m
               = (a % m + b % m) % m
所以 (a + b) % m = (a % m + b % m) % m
 
2.同余定理的减法应用（参考加法）
(a - b) % m = (a % m - b % m) % m

3.同余定理的乘法应用
(a * b) % m = ((a % m) * (b % m)) % m
设 a = k1 * m + r1，b = k2 * m + r2
则 (a * b) % m = ((k1 * m + r1) * (k2 * m + r2)) % m
               = (k1 * k2 * m^2 + (k1 * r2 + k2 * r1) * m + r1 * r2) % m
               = (r1 * r2) % m
               = ((a % m) * (b % m)) % m
所以 (a * b) % m = ((a % m) * (b % m)) % m

4.另外
(a * b * c) % d = (a % d * b % d * c % d) % d;

---

快速幂

        快速幂算法能帮我们算出指数非常大的幂，传统的求幂算法之所以时间复杂度非常高（为O(指数n)），就是因为当指数n非常大的时候，需要执行的循环操作次数也非常大。

        所以我们快速幂算法的核心思想就是每一步都把指数分成两半，而相应的底数做平方运算。这样不仅能把非常大的指数给不断变小，所需要执行的循环次数也变小，而最后表示的结果却一直不会变。让我们先来看一个简单的例子：

        3^10=3*3*3*3*3*3*3*3*3*3

        尽量想办法把指数变小来，这里的指数为10

        3^10=(3*3)*(3*3)*(3*3)*(3*3)*(3*3)

        3^10=(3*3)^5

        3^10=9^5

        此时指数由10缩减一半变成了5，而底数变成了原来的平方，求3^10原本需要执行10次循环操作，求9^5却只需要执行5次循环操作，但是3^10却等于9^5,我们用一次（底数做平方操作）的操作减少了原本一半的循环量，特别是在幂特别大的时候效果非常好，例如2^10000=4^5000,底数只是做了一个小小的平方操作，而指数就从10000变成了5000，减少了5000次的循环操作。

        现在我们的问题是如何把指数5变成原来的一半，5是一个奇数，5的一半是2.5，但是我们知道，指数不能为小数。

        因此我们不能这么简单粗暴的直接执行5/2，然而，这里还有另一种方法能表示9^5

        9^5=（9^4）*（9^1）

        此时我们抽出了一个底数的一次方，这里即为9^1，这个9^1我们先单独移出来,剩下的9^4又能够在执行“缩指数”操作了，把指数缩小一半，底数执行平方操作

        9^5=（81^2）*(9^1)

        把指数缩小一半，底数执行平方操作

        9^5=（6561^1）*(9^1)

        此时，我们发现指数又变成了一个奇数1，按照上面对指数为奇数的操作方法，应该抽出了一个底数的一次方，这里即为6561^1，这个6561^1我们先单独移出来，但是此时指数却变成了0，也就意味着我们无法再进行“缩指数”操作了。

        9^5=（6561^0）*(9^1)*(6561^1)=1*(9^1)*(6561^1)=(9^1)*(6561^1)=9*6561=59049

        我们能够发现，最后的结果是9*6561，而9是怎么产生的？是不是当指数为奇数5时，此时底数为9。那6561又是怎么产生的呢？是不是当指数为奇数1时，此时的底数为6561。

        所以我们能发现一个规律：最后求出的幂结果实际上就是在变化过程中所有当指数为奇数时底数的乘积。

问题3
a 的 b 次方
【题目描述】
给出三个整数 a,b,m，求 a^b mod m 的值。

【输入】
一行三个整数 a,b,m。

【输出】
一个整数，表示 a^b mod m 的值。

【输入样例】
2 100 1007
【输出样例】
169
【提示】
数据范围与提示：
对于全部数据，1≤a,b,m≤10^9 。

typedef long long ll;

ll quickPow(ll a, ll b, ll c) {
    ll s = 1;
    while (b) {
        if (b % 2 == 1) {
            s = s * a % c;
        }
        b /= 2;
        a = a * a % c;
    }
    return s;
}

优化

typedef long long ll;
ll quickPow(ll a, ll b, ll c) {
    ll s = 1;
    while (b) {
        if (b & 1) {
            s = s * a % c;
        }
        b >>= 1;
        a = a * a % c;
    }
    return s;
}

到这里，我们的快速幂就结束了。