快速幂与矩阵快速幂

快速幂

如果当前的指数是偶数，我们把指数拆成两半，得到两个相同的数，然后把这两个相同的数相乘，可以得到原来的数；
如果当前的指数是奇数，我们把指数拆成两半，得到两个相同的数，此时还剩余一个底数，把这两个相同的数和剩余的底数这三个数相乘，可以得到原来的数。
求解x^ｎ的值

int QuickPow(int x,int ｎ)
{
    int ans = 1;
    while(ｎ)
    {
        if(ｎ&1)
        {
            ans *=x;
        }
        x*=x;
        n = n>>1;
    }
    return ans;
}

首先，我们注意到，不管当前的指数值（n 的值）是奇数还是偶数，一次运算之后 n 都要拆成两半（n /= 2），所以，我们在每次运算的时候都要让当前的 x *= x ，也就是执行 x = x^2，这点相信不难理解。
第二，当 n 为奇数的时候，如果执行 n /= 2，结果会使得 n 损失一个 1。举个例子：假设此时 n = 9，9 / 2 = 4 ，即使我们之后会执行 x *= x，也只是把 n 的一半 (4) 补回来了，还少了个 1 （4+4+1 = 9）。因此此时要把少了的那一个 x 存入结果中，即为执行 ans *= x;
第三，只要 n 的初始值是大于 0 的（其余的数需要特殊处理），那么在运算过程中一直执行 n >>= 1，也就是将 n 除以 2 ，n 是一定会等于 1 的，此时执行 ans *= x，将最后的结果保存在 ans中，之后退出循环。
最后，整个循环每一次执行 n 都变成原来的一半，当 n 等于 0 的时候结束，时间复杂度为 O(logn)。

矩阵快速幂

矩阵快速幂是用于快速求出一个矩阵的 n 次方的方法。
首先,两个矩阵能不能相乘是有一定条件的： 矩阵 A 的列数等于矩阵 B 的行数。
对于这里，我们要求的是一个矩阵的 n 次方，那么既然是同一个矩阵，那么只有当其为方阵的时候，才可以相乘。

 struct Matrix ///结构体，矩阵类型
    {
        int m[maxn][maxn];
    }ans,res;
    Matrix Mul(Matrix a,Matrix b,int n)
    {
        Matrix tmp;//定义一个临时的矩阵，存放A*B的结果
        for(int i = 1;i <= n;i++)
        {
            for(int j = 1;j <= n;j++)
            {
                tmp.m[i][j] = 0;
            }
        }
        for(itn i=1;i <= n;i++)
        {
            for(int j = 1;j <= n;j++)
            {
                for(int k = 1;k <= n;k++)
                {
                    tmp.m[i][j] = a.m[i][k]*b.m[k][j];
                }
            }
        }
        return tmp;
    }
    ///矩阵快速幂，求矩阵res的N次幂
    void quickpower(int N,int n)
    {
        //整数快速幂默认的ans是1，矩阵的话ans应为单位矩阵
        for(int i = 1;i <= n;i++)
        {
            for(int j = 1;j <= n;j++)
            {
                if(i == j)
                    ans.m[i][j] = 1;
                else
                    ans.m[i][j] = 0;
            }
        }
        while(N)
        {
            if(N&1)
                ans = Mul(res,res);
            res = Mul(res,res);
            N = N>>1;
        }
    }