矩阵快速幂模版

最新推荐文章于 2022-03-03 17:24:39 发布
最新推荐文章于 2022-03-03 17:24:39 发布
阅读量3.5k 收藏
点赞数
分类专栏： =======数论======= 模版 矩阵快速幂
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acmmmm/article/details/10041141
版权 
#define Matr 10 //矩阵大小,注意能小就小

struct mat//矩阵结构体，a表示内容，size大小 矩阵从1开始
{
    ll a[Matr][Matr],size;
    mat()
    {
        size=0;
        memset(a,0,sizeof(a));
    }
};
void print(mat m)//输出矩阵信息，debug用 
{
    int i,j;
    printf("%d\n",m.size);
    for(i=0;i<m.size;i++)
    {
        for(j=0;j<m.size;j++)printf("%d ",m.a[i][j]);
        printf("\n");
    }
}

mat multi(mat m1,mat m2,int mod)//两个相等矩阵的乘法，对于稀疏矩阵，有0处不用运算的优化 
{
    mat ans=mat();    ans.size=m1.size;
    for(int i=1;i<=m1.size;i++)
        for(int j=1;j<=m2.size;j++)
            if(m1.a[i][j])//稀疏矩阵优化 
                for(int k=1;k<=m1.size;k++)
                    ans.a[i][k]=(ans.a[i][k]+m1.a[i][j]*m2.a[j][k])%mod;

    return ans;
}
mat quickmulti(mat m,int n,int mod)//二分快速幂 
{
    mat ans=mat();
    int i;
    for(i=1;i<=m.size;i++)ans.a[i][i]=1;
    ans.size=m.size;
    while(n)
    {
        if(n&1)ans=multi(m,ans,mod);
        m=multi(m,m,mod);
        n>>=1;
    }
    return ans;
}
/*
ans^=n ->
mat ans=mat();
ans.size=Size;
初始化ans矩阵
ans=quickmulti(ans,n,mod);
*/


 Java:（from shumj）

import java.math.BigInteger;
import java.util.Arrays;
public class Matrix {

    public static long[][] mul(long[][] a, long[][] b) {
        int n = a.length;
        long[][] c = new long[n][n];
        for (int i = 0; i < n; i++) {
            for (int k = 0; k < n; k++) if (a[i][k] != 0) {
                for (int j = 0; j < n; j++) {
                    c[i][j] = c[i][j] + a[i][k] * b[k][j];
                }
            }
        }
        return c;
    }

    public static long[][] pow(long[][] a, long b) {
        int n = a.length;
        long[][] c = new long[n][n];
        for (int i = 0; i < n; i++)
            c[i][i] = 1;
        while (b > 0) {
            if ((b & 1) != 0)
                c = mul(c, a);
            a = mul(a, a);
            b >>>= 1;
        }
        return c;
    }
    public static double[][] mul(double[][] a, double[][] b) {
        int n = a.length;
        double[][] c = new double[n][n];
        for (int i = 0; i < n; i++) {
            for (int k = 0; k < n; k++) if (a[i][k] != 0) {
                for (int j = 0; j < n; j++) {
                    c[i][j] = c[i][j] + a[i][k] * b[k][j];
                }
            }
        }
        return c;
    }

    public static double[][] pow(double[][] a, long b) {
        int n = a.length;
        double[][] c = new double[n][n];
        for (int i = 0; i < n; i++)
            c[i][i] = 1;
        while (b > 0) {
            if ((b & 1) != 0)
                c = mul(c, a);
            a = mul(a, a);
            b >>>= 1;
        }
        return c;
    }

    public static long[][] mul(long[][] a, long[][] b, long mod) {
        int n = a.length;
        long[][] c = new long[n][n];
        for (int i = 0; i < n; i++) {
            for (int k = 0; k < n; k++) {
                for (int j = 0; j < n; j++) {
                    c[i][j] = (c[i][j] + a[i][k] * b[k][j]) % mod;
                }
            }
        }
        return c;
    }

    public static long[][] pow(long[][] a, long b, long mod) {
        int n = a.length;
        long[][] c = new long[n][n];
        for (int i = 0; i < n; i++)
            c[i][i] = 1;
        while (b > 0) {
            if ((b & 1) != 0)
                c = mul(c, a, mod);
            a = mul(a, a, mod);
            b >>>= 1;
        }
        return c;
    }
    public static int[][] mul(int[][] a, int[][] b) {
        int n = a.length;
        int[][] c = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int k = 0; k < n; k++) {
                for (int j = 0; j < n; j++) {
                    c[i][j] = c[i][j] + a[i][k] * b[k][j];
                }
            }
        }
        return c;
    }

    public static int[][] pow(int[][] a, int b) {
        int n = a.length;
        int[][] c = new int[n][n];
        for (int i = 0; i < n; i++)
            c[i][i] = 1;
        while (b > 0) {
            if ((b & 1) != 0)
                c = mul(c, a);
            a = mul(a, a);
            b >>>= 1;
        }
        return c;
    }

    public static int[][] mul(int[][] a, int[][] b, int mod) {
        int n = a.length;
        int[][] c = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int k = 0; k < n; k++) if (a[i][k] != 0) {
                for (int j = 0; j < n; j++) {
                    c[i][j] = (c[i][j] + a[i][k] * b[k][j]) % mod;
                }
            }
        }
        return c;
    }

    public static int[][] pow(int[][] a, int b, int mod) {
        int n = a.length;
        int[][] c = new int[n][n];
        for (int i = 0; i < n; i++)
            c[i][i] = 1;
        while (b > 0) {
            if ((b & 1) != 0)
                c = mul(c, a, mod);
            a = mul(a, a, mod);
            b >>>= 1;
        }
        return c;
    }

    public static final double EPS = 1e-8;

    public static double[][] solutionSpace(double[][] A, double[] b) {
        int n = A.length, m = A[0].length;
        double[][] a = new double[n][m + 1];
        for (int i = 0; i < n; i++) {
            System.arraycopy(A[i], 0, a[i], 0, m);
            a[i][m] = b[i];
        }
        int[] id = new int[n + 1]; // 第 i 行的第一个非零元 1 所在的位置是 id[i]
        Arrays.fill(id, -1);
        int pi = 0; // 矩阵 A 的秩
        for (int pj = 0; pi < n && pj < m; pj++) {
            for (int i = pi + 1; i < n; i++) {
                if (Math.abs(a[i][pj]) > Math.abs(a[pi][pj])) {
                    double[] t = a[i];
                    a[i] = a[pi];
                    a[pi] = t;
                }
            }
            if (Math.abs(a[pi][pj]) < EPS) // 当前列已经全零
                continue;
            double inv = 1 / a[pi][pj]; // 如果取模运算，可以用大数模逆
            for (int j = 0; j <= m; j++) // 化主元为 1，可以优化
                a[pi][j] *= inv;
            for (int i = 0; i < n; i++)
                if (i != pi) {
                    double d = a[i][pj];
                    for (int j = 0; j <= m; j++) // 化当前列为 0，可以优化
                        a[i][j] -= d * a[pi][j];
                }
            id[pi++] = pj;
        }
        for (int i = pi; i < n; i++)
            if (Math.abs(a[i][m]) > EPS) // 增广矩阵的秩更大，无解
                return null;
        double[][] X = new double[1 + m - pi][m];
        for (int j = 0, k = 0; j < m; j++) {
            if (id[k] == j)
                X[0][j] = a[k++][m];
            else {
                for (int i = 0; i < k; i++)
                    X[1 + j - k][id[i]] = -a[i][j];
                X[1 + j - k][j] = 1;
            }
        }
        return X;
    }

    public static long[][] solutionSpace(long[][] A, long[] b, long mod) {
        int n = A.length, m = A[0].length;
        BigInteger MOD = BigInteger.valueOf(mod);
        long[][] a = new long[n][m + 1];
        for (int i = 0; i < n; i++) {
            System.arraycopy(A[i], 0, a[i], 0, m);
            a[i][m] = b[i];
        }
        int[] id = new int[n + 1]; // 第 i 行的第一个非零元 1 所在的位置是 id[i]
        Arrays.fill(id, -1);
        int pi = 0; // 矩阵 A 的秩
        for (int pj = 0; pi < n && pj < m; pj++) {
            for (int i = pi + 1; i < n; i++) {
                if (Math.abs(a[i][pj]) > Math.abs(a[pi][pj])) {
                    long[] t = a[i];
                    a[i] = a[pi];
                    a[pi] = t;
                }
            }
            if (Math.abs(a[pi][pj]) < EPS) // 当前列已经全零
                continue;
            //double inv = 1 / a[pi][pj]; // 如果取模运算，可以用大数模逆
            long inv = BigInteger.valueOf(a[pi][pj]).modInverse(MOD).longValue();
            for (int j = 0; j <= m; j++) // 化主元为 1，可以优化
                a[pi][j] = (a[pi][j] * inv) % mod;
            for (int i = 0; i < n; i++)
                if (i != pi) {
                    long d = a[i][pj];
                    for (int j = 0; j <= m; j++) // 化当前列为 0，可以优化
                        a[i][j] = (a[i][j] - d * a[pi][j] % mod) % mod;
                }
            id[pi++] = pj;
        }
        for (int i = pi; i < n; i++)
            if (Math.abs(a[i][m]) > EPS) // 增广矩阵的秩更大，无解
                return null;
        long[][] X = new long[1 + m - pi][m];
        for (int j = 0, k = 0; j < m; j++) {
            if (id[k] == j)
                X[0][j] = a[k++][m];
            else {
                for (int i = 0; i < k; i++)
                    X[1 + j - k][id[i]] = -a[i][j];
                X[1 + j - k][j] = 1;
            }
        }
        return X;
    }

    public static boolean[][] solutionSpace(boolean[][] A, boolean[] b) {
        int n = A.length, m = A[0].length;
        boolean[][] a = new boolean[n][m + 1];
        for (int i = 0; i < n; i++) {
            System.arraycopy(A[i], 0, a[i], 0, m);
            a[i][m] = b[i];
        }
        int[] id = new int[n + 1]; // 第 i 行的第一个非零元 1 所在的位置是 id[i]
        Arrays.fill(id, -1);
        int pi = 0; // 矩阵 A 的秩
        for (int pj = 0; pi < n && pj < m; pj++) {
            for (int i = pi + 1; i < n; i++) {
                if (a[i][pj] && !a[pi][pj]) {
                    boolean[] t = a[i];
                    a[i] = a[pi];
                    a[pi] = t;
                }
            }
            if (!a[pi][pj]) // 当前列已经全零
                continue;
            for (int i = 0; i < n; i++)
                if (i != pi) {
                    boolean d = a[i][pj];
                    for (int j = 0; j <= m; j++) // 化当前列为 0，可以优化
                        a[i][j] ^= d & a[pi][j];
                }
            id[pi++] = pj;
        }
        for (int i = pi; i < n; i++)
            if (a[i][m]) // 增广矩阵的秩更大，无解
                return null;
        boolean[][] X = new boolean[1 + m - pi][m];
        for (int j = 0, k = 0; j < m; j++) {
            if (id[k] == j)
                X[0][j] = a[k++][m];
            else {
                for (int i = 0; i < k; i++)
                    X[1 + j - k][id[i]] = a[i][j];
                X[1 + j - k][j] = true;
            }
        }
        return X;
    }

    // max{cx | Ax <= b, x >= 0}
    public static double[] simplex(double[][] A, double[] b, double[] c) {
        int n = A.length, m = A[0].length + 1, r = n, s = m - 1;
        double[][] D = new double[n + 2][m + 1];
        int[] ix = new int[n + m];
        for (int i = 0; i < n + m; i++) ix[i] = i;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m - 1; j++)
                D[i][j] = -A[i][j];
            D[i][m - 1] = 1;
            D[i][m] = b[i];
            if (D[r][m] > D[i][m]) r = i;
        }
        for (int j = 0; j < m - 1; j++) D[n][j] = c[j];
        D[n + 1][m - 1] = -1;
        for (double d;;) {
            if (r < n) {
                int t = ix[s]; ix[s] = ix[r + m]; ix[r + m] = t;
                D[r][s] = 1.0 / D[r][s];
                for (int j = 0; j <= m; j++) if (j != s) D[r][j] *= -D[r][s];
                for (int i = 0; i <= n + 1; i++) if (i != r) {
                        for (int j = 0; j <= m; j++) if (j != s)
                                D[i][j] += D[r][j] * D[i][s];
                        D[i][s] *= D[r][s];
                    }
            }
            r = -1; s = -1;
            for (int j = 0; j < m; j++)
                if (s < 0 || ix[s] > ix[j]) {
                    if (D[n + 1][j] > EPS || D[n + 1][j] > -EPS && D[n][j] > EPS) s = j;
                }
            if (s < 0) break;
            for (int i = 0; i < n; i++) if (D[i][s] < -EPS) {
                    if (r < 0 || (d = D[r][m] / D[r][s] - D[i][m] / D[i][s]) < -EPS
                            || d < EPS && ix[r + m] > ix[i + m]) r = i;
                }
            if (r < 0) return null;
        }
        if (D[n + 1][m] < -EPS) return null;
        double[] x = new double[m - 1];
        for (int i = m; i < n + m; i++) if (ix[i] < m - 1) x[ix[i]] = D[i - m][m];
        return x;
    }
}


九野的博客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
矩阵快速幂(标准模板)
Spf小鱼干
03-15 308
题目描述 给定n*n的矩阵A，求A^k 输入输出格式 输入格式： 第一行，n,k 第2至n+1行，每行n个数，第i+1行第j个数表示矩阵第i行第j列的元素 输出格式： 输出A^k 共n行，每行n个数，第i行第j个数表示矩阵第i行第j列的元素，每个元素模10^9+7 输入输出样例 输入样例#1： 2 1 1 1 1 1 输出样例#1： 1 1 1 1 说明 n&amp;lt;=100, k&amp;lt;=10...
矩阵快速幂模板以及其应用矩阵加速递推
M3ng@L的博客
08-27 823
计算这样的递推次数很多的式子，我们需要一个更简化更快捷的计算方式，也就是矩阵快速幂。我们只需要构造最小限度能解决问题的矩阵就好，无论是矩阵初始值还是转移矩阵，所以还是需要具体问题具体分析地来构造矩阵。的矩阵，其实列向量还是行向量都可以，只要转移矩阵也是对应的即可）那么根据转移矩阵表现出来的与原数列的关系，我们可以这样来看。的矩阵初始值浪费了计算空间，所以构造其他形式的初始矩阵。的初始矩阵的话，对应数列的递推关系是不完整的；得到的新矩阵的第一项数据即是斐波那契数列的第。把矩阵乘法展开，得到。......
矩阵快速幂 原理 模板
LarsGyonX的博客
03-03 251
一、矩阵乘法 矩阵A*B=C，公式: ，三重循环。 前提条件：n*n的矩阵 看代码： const int N=100; int c[N][N]; void multi(int a[][N],int b[][N],int n)//n是矩阵大小，n<N { memset(c,0,sizeof c); for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) for(int k=1;k<=n;k++)
矩阵
Lassi的博客
03-19 154
用结构体表示矩阵： const int MAXN = 100; struct Matrix { int row, col; int matrix[MAXN][MAXN]; Matrix(int r, int c) : row(r), col(c){} //构造函数 } 考点： 矩阵相加 矩阵相乘 矩阵转置 矩阵求幂 矩阵的输入输出： void InputMatrix(Matrix& x){ for(int i = 0; i < x.row; ++i){ for(int j
矩阵模板
weixin_30567471的博客
09-24 79
struct Matrix { int a[2][2]; Matrix() { memset(a,0,sizeof(a)); } void init() { for(int i=0;i<2;i++) for(int j=0;j<2;j++) ...
矩阵快速幂_矩阵快速幂_
09-30
为了方便使用，我们可以将矩阵快速幂封装成一个库或者模板类。封装时，需要考虑以下几个方面： 1. **模板设计**：由于矩阵的元素可以是各种类型（如int, long long, 或者自定义的大整数类型），使用模板类可以提供...
yxy版c++教程 浅谈矩阵快速幂
01-09
在C++中，矩阵快速幂可以通过模板实现，提高了计算效率。 矩阵概念 矩阵是指纵横排列的二维数据表格，同质上是一个m*n的二维数组。矩阵可以用于表示图像、信号处理、机器学习等领域的数据。矩阵乘法是矩阵运算的...
ACM模板——矩阵快速幂
11-15
矩阵快速幂的模板，需要自己根据实际题目更改矩阵大小和数据类型，以免WA和TLE。经过矩阵乘法上的稀疏矩阵优化和int64的乘法取模幂优化，效率应该比较高。视情况使用mult()函数或直接使用乘法。代码中每个函数有注释...
斐波那契矩阵快速幂.cpp
04-15
斐波那契矩阵快速幂模版
矩阵快速幂套路模板.cpp
07-13
矩阵快速幂套路模板.cpp
矩阵快速幂模板（解决斐波那契数列和HDU 5015 233 Matrix）
Kerin的博客
07-17 313
a156=a100111002=a27∗1+26∗0+25∗0+24∗1+23∗1+22∗1+21∗0+20∗0a^{156}=a^{10011100_2}=a^{2^7*1 + 2^6*0 + 2^5*0+2^4*1+2^3*1+2^2*1+2^1*0+2^0*0}a156=a100111002​=a27∗1+26∗0+25∗0+24∗1+23∗1+22∗1+21∗0+20∗0 普通快速幂的模板： int fastPow(int base,int n,int mod){ int ans=1;//单
矩阵快速幂模板
indiewar's blogs(wust_lzl)
05-04 101
const int maxn = 2; struct Matrix{ ll a[maxn][maxn]; void init(){ memset(a, 0, sizeof(a)); for(int i=0;i<maxn;++i){ a[i][i] = 1; } } }; Matrix ...
hdoj 1575 Tr A (矩阵快速幂)
R
11-13 1852
Tr A Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4549    Accepted Submission(s): 3428 Problem Description A为一个方阵，则Tr A表示A的迹（就是主
数论基础——矩阵快速幂模板
ly's Blog
05-05 715
1.矩阵简介： 2.单位矩阵： 3.矩阵的加减： 4.常数k与矩阵相乘： 5.矩阵与矩阵相乘： 矩阵乘矩阵就是要我们模拟线性代数中矩阵求矩阵的公式，新的矩阵的第一个数就等于矩阵A的第一行的每一个元素乘上矩阵B的每一列的元素相加起来得到，那么新的矩阵的第m个元素就等于矩阵A的m行的每一个元素乘以矩阵B的m列每一个元素相加即可。 Code: struct matrix { int n,...
HDU 6030（矩阵快速幂+规律）
Chen.Jr的博客
04-20 765
传送门题目描述：Happy NecklaceTime Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)Total Submission(s): 1146    Accepted Submission(s): 491Problem Description Little Q wants to...
矩阵快速幂练习
味辣鸡的基地
05-28 436
参考 http://m.blog.csdn.net/article/details?id=52058209应用篇 主要通过把数放到矩阵的不同位置，然后把普通递推式变成"矩阵的等比数列"，最后快速幂求解递推式: 先通过入门的题目来讲应用矩阵快速幂的套路(会这题的也可以看一下套路)： 例一: http://poj.org/problem?id=3070 题目：斐波那契数列f(n),给一个n，求f(n)
矩阵快速幂 模板
MikeJackSTG的博客
04-16 219
#include &lt;iostream&gt;#include &lt;cstdio&gt;using namespace std;const int maxn=110;const int  mod=1e9+7;//#define Mod(x) ((x)%mod)typedef long long ll;struct node{    int a[maxn][maxn];} unit;//单位...
线性代数matlab上机 模板及答案 复习资料.pdf
最新发布
03-16
- 幂运算：矩阵乘法的幂运算，如`(A*B)^100`，在MATLAB中可以计算大整数幂，但要注意当矩阵不是对称或单位矩阵时，高次幂可能会导致数值溢出，如这里出现了科学计数法表示的极大值。 4. 行列式计算：`det`函数用于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值