矩阵相关操作

已于 2024-01-16 18:05:45 修改
阅读量158 收藏
点赞数
文章标签： 矩阵 线性代数 机器学习
于 2022-07-31 13:18:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55788328/article/details/126063308
版权

线性代数都快忘完了，先挖个坑...

矩阵加速递推

我们将第n项斐波那契数列记作F_{n}

考虑 F_{n}=F_{n-1}+F_{n-2} ,把斐波那契数列的相邻两项放在一个行矩阵里面，就像这个样子：\left[\begin{array}{ll} F_{i} & F_{i-1} \end{array}\right]

我们需要把 \left[\begin{array}{ll} F_{i} & F_{i-1} \end{array}\right]变成\left[F_{i-1}+F_{i} \quad F_{i}\right]需要用到矩阵乘法

因为我们一开始的\left[\begin{array}{ll} 1 & 1 \end{array}\right]是\left[\begin{array}{ll} F_{2} & F_{1} \end{array}\right]所以我们只需要将其乘以 \left[\begin{array}{ll} 1 & 1 \\ 1 & 0 \end{array}\right]^{n-2}即可得到F_{n}

当n很大的时候比如为1e18,通过直接乘是肯定会TLE的，所以考虑使用快速幂，这样就可以在log的时间里面求出答案，加速成功

#include <cstdio>
using namespace std;
 
struct Matrix{
    static const int MOD = 10007;
    int data[2][2];
    Matrix(int data00, int data01, int data10, int data11){
        data[0][0] = data00; data[0][1] = data01;
        data[1][0] = data10; data[1][1] = data11;
    }
    Matrix operator * (const Matrix &a) const{
        Matrix ans = Matrix(0, 0, 0, 0);
        for(int i = 0; i<2; ++i)
            for(int j = 0; j<2; ++j)
                for(int k = 0; k<2; ++k) 
                    ans.data[i][j] = (ans.data[i][j] + data[i][k]*a.data[k][j])%MOD;
        return ans;
    }
    Matrix pow( int power){
        Matrix ans = Matrix(1, 0, 0, 1);
        Matrix base = (*this);
        while(power){
            if(power&1) ans = ans * base;
            base = base * base;
            power >>= 1;
        }
        return ans;
    }
};
 
int main(){
    int n;
    scanf("%d", &n);
    Matrix ans = Matrix(1, 1, 1, 0);
    printf("%d\n", ans.pow(n).data[1][0]);
    return 0;
}

线段树维护矩阵乘法

大魔法师

把1-6的操作用乘上对应的矩阵实现,那么只要使用线段树维护矩阵即可

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int maxn=2.5e5+5;
const int mod=998244353;
struct Matrix{
	int n,m;
	int a[5][5];
	Matrix(){}
	Matrix(int _n,int _m):n(_n),m(_m){
		memset(a,0,sizeof(a));
	}
	Matrix operator+(const Matrix& rhs){
		Matrix res(n,m);
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				res.a[i][j]=(a[i][j]+rhs.a[i][j])%mod;
			}
		}
		return res;
	}
	Matrix operator*(const Matrix &rhs){
		Matrix res(n,rhs.m);
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				for(int k=1;k<=rhs.m;k++){
					res.a[i][k]=(res.a[i][k]+a[i][j]*rhs.a[j][k])%mod;
				}
			}
		}
		return res;
	}
};
Matrix num[maxn];
struct SegTree{
	int l,r;
	Matrix sum,tag;
}tr[maxn<<2];
Matrix base,base1,base2,base3,base4,base5,base6;
void init(){
    base=Matrix(4,4);
	for(int i=1;i<=4;i++){
		base.a[i][i]=1;
	}
	/*
	base1:| base2:| base3:
	1 0 0 0| 1 0 0 0| 1 0 1 0
	1 1 0 0| 0 1 0 0| 0 1 0 0
	0 0 1 0| 0 1 1 0| 0 0 1 0
	0 0 0 1| 0 0 0 1| 0 0 0 1
	*/
	base1=base,base2=base,base3=base;
	base1.a[2][1]=1;
	base2.a[3][2]=1;
	base3.a[1][3]=1;
	/*
	base4:  | base5:  | base6:
	1 0 0 0 | 1 0 0 0 | 1 0 0 0
	0 1 0 0 | 0 k 0 0 | 0 1 0 0
	0 0 1 0 | 0 0 1 0 | 0 0 0 0
	k 0 0 1 | 0 0 0 1 | 0 0 k 1
	 */
	base4=base,base5=base,base6=base;
	base6.a[3][3]=0;
}
void build(int p,int l,int r){
	tr[p].l=l,tr[p].r=r;
	if(l==r){
		tr[p].sum=num[l];
		tr[p].tag=base;
		return;
	}
	int m=(l+r)>>1;
	build(p<<1,l,m);
	build(p<<1|1,m+1,r);
	tr[p].sum=tr[p<<1].sum+tr[p<<1|1].sum;
	tr[p].tag=base;
	return;
}
void pushdown(int p){
	auto &root=tr[p],&left=tr[p<<1],&right=tr[p<<1|1];
	left.sum=left.sum*root.tag;
	right.sum=right.sum*root.tag;
	left.tag=left.tag*root.tag;
	right.tag=right.tag*root.tag;
	root.tag=base;
	return;
}
void segadd(int p,int l,int r,Matrix k){
	if(tr[p].l>=l&&tr[p].r<=r){
		tr[p].tag=tr[p].tag*k;
		tr[p].sum=tr[p].sum*k;
		return;
	}
	pushdown(p);
	int m=(tr[p].l+tr[p].r)>>1;
	if(l<=m){
		segadd(p<<1,l,r,k);
	}
	if(r>m){
		segadd(p<<1|1,l,r,k);
	}
	tr[p].sum=tr[p<<1].sum+tr[p<<1|1].sum;
	return;
}
Matrix segsum(int p,int l,int r){
	if(tr[p].l>=l&&tr[p].r<=r){
		return tr[p].sum;
	}
	pushdown(p);
	int m=(tr[p].l+tr[p].r)>>1;
	Matrix res(4,4);
	if(l<=m){
		res=res+segsum(p<<1,l,r);
	}
	if(r>m){
		res=res+segsum(p<<1|1,l,r);
	}
	return res;
}
signed main(){
	init();
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		num[i]=Matrix(1,4);
		for(int j=1;j<=3;j++){
			cin>>num[i].a[1][j];
		}
		num[i].a[1][4]=1;
	}
	build(1,1,n);
	int m;
	cin>>m;
	while(m--){
		int op,l,r,k;
		cin>>op>>l>>r;
		if(op==1){
			segadd(1,l,r,base1);
		}
		else if(op==2){
			segadd(1,l,r,base2);
		}
		else if(op==3){
			segadd(1,l,r,base3);
		}
		else if(op==4){
			cin>>k;
			base4.a[4][1]=k;
			segadd(1,l,r,base4);
		}
		else if(op==5){
			cin>>k;
			base5.a[2][2]=k;
			segadd(1,l,r,base5);
		}
		else if(op==6){
			cin>>k;
			base6.a[4][3]=k;
			segadd(1,l,r,base6);
		}
		else if(op==7){
			Matrix res=segsum(1,l,r);
			cout<<res.a[1][1]<<" "<<res.a[1][2]<<" "<<res.a[1][3]<<"\n";
		}
	}
}

高斯消元 (求行列式，时间复杂度n^3)

const double EPS = 1E-9;
int n;
vector<vector<double> > a(n, vector<double>(n));

double det = 1;
for (int i = 0; i < n; ++i) {
  int k = i;
  for (int j = i + 1; j < n; ++j)
    if (abs(a[j][i]) > abs(a[k][i])) k = j;
  if (abs(a[k][i]) < EPS) {
    det = 0;
    break;
  }
  swap(a[i], a[k]);
  if (i != k) det = -det;
  det *= a[i][i];
  for (int j = i + 1; j < n; ++j) a[i][j] /= a[i][i];
  for (int j = 0; j < n; ++j)
    if (j != i && abs(a[j][i]) > EPS)
      for (int k = i + 1; k < n; ++k) a[j][k] -= a[i][k] * a[j][i];
}

cout << det;

双指针规避矩阵除法

对于一个矩阵连续区间l-r相乘，如果要求l+1-r,即删掉l这个矩阵，那么就要乘以l这个矩阵的逆矩阵，这个可以用高斯消元解决，但是如果矩阵不是可逆的，那么就不能执行删除操作了，所以考虑使用双指针的办法l,r用来表示当前的左右端点，如果可行则r++，否则l++，但是这样还是没有实现删除操作，所以另外加一个limit，base矩阵代表limit+1-r的乘积，b[i]预处理一下，代表i-limit的乘积，当目前可行时，则r++，否则l++，如果l>limit，那么就把limit赋值为r，然后预处理算出limit+1-r的b[i]，并且令因为当前limit+1=r+1，limit+1-r目前没有矩阵，所以把base赋值为1，重新开始新的一轮，这样可以实现O(1)的转移

Link with Bracket Sequence II

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int inf=1e9+8;
ll n,m,k;
struct square{
	ll v[22][22];
	square(int x=0){
		memset(v,0,sizeof(v));
		for(int i=1;i<=m;i++){
			v[i][i]=x;
		}
	}
	square operator *(square q){
		square ans;
		for(int i=1;i<=m;i++){
			for(int j=1;j<=m;j++){
				for(int k=1;k<=m;k++){
					ans.v[i][j]=ans.v[i][j]+v[i][k]*q.v[k][j];
					if(ans.v[i][j]>inf){//多次累乘可能越界，过大就处理一下
						ans.v[i][j]=inf;
					}
				}
			}
		}
		return ans;
	}
	void print(){
		for(int i=1;i<=m;i++){
			for(int j=1;j<=m;j++){
				cout<<v[i][j]<<" ";
			}
			cout<<endl; 
		}
	}
};
square a[5010];
square b[5010];
bool check(square x,square y){//判断当前方案数是否超出k
	ll ans=0;
	for(int i=1;i<=m;i++){
		ans+=x.v[1][i]*y.v[i][m];
		if(ans>k){
			return 0;
		}
	}
	return 1;
}
int main(){
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//同步流
	int t;
	cin>>t;
	while(t--){
		cin>>n>>m>>k;
		for(int i=1;i<=n;i++){
			int l;
			cin>>l;
			a[i]=1;
			for(int j=1;j<=l;j++){
				int u,v;
				cin>>u>>v;
				a[i].v[u][v]=1;
			}
		}
		int ans=0;
		b[0].v[1][m]=inf;//初始化
		square base=1;
		for(int l=0,lim=0,r=1;r<=n;r++){
			base=base*a[r];//储存a[lim+1]-a[r]的累乘和
			while(!check(b[l],base)){//方案数过多，开始缩小区间，查找当前人对应的l
				//根据base,和b[i]的含义，b[l]*base即为a[l]-a[r]的累乘和
				l++;
				if(l>lim){//l超过lim了，此时lim后面的b还没有定义，需要更新lim和对应的b
					base=1;
					b[r]=a[r];//b[i]储存的是a[i]-a[lim]间的累乘和，
					for(int i=r-1;i>lim;i--){
						b[i]=a[i]*b[i+1];
					}
					lim=r;
				}
			}
			ans=max(ans,r-l+1);//更新答案
		}
		cout<<ans<<endl;
	}
	return 0;
}

b1ue1ue1ue
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
矩阵相关操作——C++实现
weixin_44788162的博客
10-06 3240
注：操作较复杂，不建议写数值课设的同学借鉴 1. 定义矩阵结构体 矩阵是高等代数(线性代数)中的基本运算单位，在运算时具有一些特殊的性质。按定义来看，矩阵是由非质数(m × n)个基本元素单元组成，这些单元按一定的顺序排列，构成了一个m行n列的矩阵。 从定义中不难看出，定义矩阵的结构体需要包含三个数据成员： 行数(整型); 列数(整型); 各元素的值(根据计算精度需求进行调整). 于是定义矩阵...
numpy矩阵操作详解
qq_45780511的博客
05-01 4738
1、numpy矩阵库(Matrix) ➢NumPy中包含了- -个矩阵库numpy.matlib, 该模块中的函数返回的是一 个矩阵，而不是ndarray对象。 ➢一个mxn的矩阵是一个由m行(row) n列(column) 元素排列成的矩形阵列。 ➢矩阵里的元素可以是数字、符号或数学式。 ➢NumPy 和Matlab不一样，对于多维数组的运算，缺省情况 下并不使用矩阵运算,如果你希望对数组进行矩...
python 之 矩阵相关操作
牛牛博士博客
10-22 793
python 之 矩阵相关操作
Mathematica 矩阵基础操作指南
qq_39538718的博客
08-03 1377
最近笔者在日常的工作和研究中，常常需要进行各种矩阵操作，尤其是大规模符号矩阵的计算MATLAB 运行显得很吃力。无论是基本的矩阵运算，还是复杂的线性代数应用，Mathematica 都能提供便捷的解决方案。Mathematica 强大的计算和可视化功能，使得矩阵计算不仅简单，而且非常高效。在这篇博客中，我将详细介绍如何在 Mathematica 中进行矩阵的基本操作，包括创建矩阵、矩阵运算、矩阵分解、以及矩阵的可视化。在 Mathematica 中，创建矩阵非常简单，矩阵可以通过列表来定义。
Matlab矩阵操作
FPGA/MATLAB学习教程/源码/项目合作开发
03-25 8315
第一部分：矩阵基本知识 矩阵是进行数据处理和运算的基本元素。在MATLAB中 a、通常意义上的数量（标量）可看成是”1*1″的矩阵； b、n维矢量可看成是”n*1″的矩阵； c、多项式可由它的系数矩阵完全确定。 一、矩阵的创建 在MATLAB中创建矩阵有以下规则： a、矩阵元素必须在”[ ]”内； b、矩阵的同行元素之间用空格（或”,”）隔开； c、矩阵的行与行之间用”;”（或回车符）隔开； d、矩阵的元素可以是数值、变量、表达式或函数； e、矩阵的尺寸不必预先定义。 下面介绍四种矩阵的创建方法：
Python之Numpy矩阵操作
liuqihang11的博客
07-28 4559
Numpy是Python的一个重要科学计算库。 矩阵操作是深度学习、数值计算的重要部分。 只介绍矩阵操作的代码实现，不介绍数学原理。 下面是一些常用的使用Numpy库矩阵操作。 importnumpyasnp写在最前面，代码段中不再添加 1 矩阵创建 （1）通过列表创建矩阵 a3 = np.mat([[1], [2], [3]]) （2）创建特殊元素矩阵 data1 = np.mat(np.zeros((2, 3))) # 创建一个2行3列的全0矩阵 data2 = np.ma...
Eigen之矩阵基本操作
weixin_42024702的博客
03-18 3194
开篇介绍 在实际应用中，当要进行姿态解算时，必不可少的便是矩阵操作，这里我们引入Eigen这一矩阵操作库。Eigen是一个C++开源线性代数库，它提供了快速的有关矩阵的线性代数运算，还包括解方程等功能。本博客通过一些实例应用，演示Eigen下矩阵逆运算、伴随矩阵运算、行列式计算和特征值、特征向量的计算等等。 一、旋转矩阵 我们知道向量的内积可以描述向量之间的投影关系，而向量的外积，能表示向量的旋转。在欧氏变换中，首先来考虑旋转。我们设某个单位正交基(e1,e2,e3)(e_1,e_2,e_3)(e1​,e2
tensorflow2.0—矩阵向量相关操作
Elvis__c的博客
05-06 1107
张量的一些数学操作一 、标量运算1 maximum 与 minimum2 幅值裁剪clip_by_value 与 clip_by_norm 二、 向量运算1 reduce_sum、mean、max、min2 reduce_prob 乘积3 reduce_all 与 reduce_any [逻辑符and or】4 foldr 实现匿名函数5 cum累计6 argmax 与 argmmin 极值索引7 top_k 排序 三、 矩阵运算1 矩阵乘法@、转置、逆、范数、行列式2 矩阵分解1.矩阵正交三角（QR）分
C# 矩阵的相关操作
laocooon的博客
02-13 670
C# 矩阵的相关操作。
matlab矩阵基本操作,Matlab入门----矩阵的基本操作
weixin_28936865的博客
03-23 4898
注意：其他编程语言一次只能处理一个数字，而 MATLAB 可以轻松快捷地处理整个矩阵！1.矩阵的创建输入元素的明确列表从外部数据文件加载矩阵使用内置函数生成矩阵使用自己的函数创建矩阵，并将其保存在文件中zeros全部为零ones全部为 1rand均匀分布的随机元素randn正态分布的随机元素2.MATLAB 允许您使用单一的算术运算符或函数来处理矩阵中的所有值。3.用 * 进行标准的矩阵相乘，确认...
C语言实现矩阵相关操作
02-03
矩阵的运算可运用在多个领域，诸如：线性系统，图像处理，机器学习等，本文档主要用C语言来实现矩阵相关的操作。
数据结构-矩阵相关操作的课程设计.doc
09-28
【数据结构-矩阵相关操作的课程设计】 课程设计的核心是实现矩阵的相关操作，包括矩阵的存储、加法、减法、乘法以及转置。在数据结构的学习中，矩阵是一种重要的数据组织形式，通常用于表示二维数组。这次设计旨在...
数组与特殊矩阵基本操作及练习
08-06
在IT领域，数组和特殊矩阵是数据结构中的基础概念...总之，理解数组和特殊矩阵的基本操作及其应用是提升编程技能和解决问题的关键。熟练掌握这些知识点，将有助于你在数据结构和算法的学习以及实际项目开发中游刃有余。
BC131 矩阵相等判定（c语言）
scy2429828663的博客
08-23 528
【代码】BC131 矩阵相等判定（c语言）
抖音收回“作品代发布”能力？短视频矩阵工具未来何去何从？
hy14762的博客
08-23 259
小魔推是一款Ai短视频剪辑工具，能够自动地从这些素材中挑选出最佳片段，并实现不重复的视频素材拼接，生成海量的原创视频内容。2、镜头快剪模式：用户可以按照分镜头上传视频素材，调节参数，场景拼接视频更加有逻辑性，同样支持AI写文案，AI口播，转场、滤镜等功能。1、一键成片模式：一键生成视频，简单快捷,AI批量生成口播文案，自动匹配视频，创作更加高时效。3.智能分发多平台视频，D音，K手，视P号，小H书，多平台覆盖提升曝光率。
数学基础 -- 线性代数之增广矩阵
最新发布
sz66cm 学习随笔
08-26 711
增广矩阵（Augmented Matrix）是在求解线性方程组时常用的工具。它将线性方程组的系数矩阵与常数项合并在一起，形成一个扩展的矩阵，从而便于使用矩阵操作方法求解方程组。假设我们有一个线性方程组：a11x1+a12x2+⋯+a1nxn=b1a21x1+a22x2+⋯+a2nxn=b2⋮am1x1+am2x2+⋯+amnxn=bm \begin{aligned} a_{11}x_1 + a_{12}x_2 + \dots + a_{1n}x_n &= b_1 \\ a_{21}x_1 + a_{22}x
7-2 求矩阵的最大值（设惟一）
Virgo_616的博客
08-26 123
本题要求编写程序，求一个给定的m×n矩阵的最大值以及位置。题目保证最大值惟一。
日撸Java三百行（day31：整数矩阵及其运算）
2301_80594618的博客
08-22 922
从今天开始，我们就要踏上图论的学习之路了。第一天，我们先简单热个身，构造一个整数矩阵。总的来说，今天的内容以及代码难度还是比较简单的，毕竟我们之前已经学过矩阵的一些运算了，所以今天的整数矩阵可以算是一个回顾；不过同时，今天也是一个铺垫，因为明天我们就会学习图的连通性，会涉及到邻接矩阵、连通矩阵，这就需要以今天的内容为基础进行延伸。
【Java 搜索二维矩阵 I II，多数元素 I II，分治法 & 二分法 & 摩尔投票法】
独上高楼，望尽天涯路。
08-23 691
Java 搜索二维矩阵 I II，多数元素 I II，分治法 & 二分法 & 摩尔投票法 & 集合计数
MATLAB矩阵操作详解及实例演示
"MATLAB相关矩阵操作与相关实例" 在MATLAB中，矩阵是核心运算对象，这使得它成为科学计算和工程应用的理想工具。本文深入介绍了如何在MATLAB环境中进行矩阵操作，包括矩阵的表示、生成以及基本运算。 1.1矩阵的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值