矩阵小结

最新推荐文章于 2021-03-24 15:34:34 发布
最新推荐文章于 2021-03-24 15:34:34 发布
阅读量1.2k 收藏
点赞数
分类专栏： 数学 文章标签： 矩阵 数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acvcla/article/details/46064845
版权

1.矩阵快速幂，用倍增来加速(O(n^3*logk))

2.矩阵求解递推关系第n项（n很大）可以构造矩阵，用矩阵快速幂迅速求出。

3.给定起点和终点求从起点到终点恰好进过k步的方案数可以直接对可达矩阵相乘k次得到结果

4.矩阵乘法的顺序对时间影响比较大（提高Cache命中率），kij最快而且还可以进行稀疏矩阵加速（当a[i][k]为0时没必要进行运算）。

因为最近在搞矩阵，所以准备写一个矩阵模板类。结果遇到不少坑，毕竟平时没怎么使用动态分配内存，只好先用静态数组水过，搞完之后调试很久才写出矩阵的动态版本，主要是开始写模板矩阵的时候没有创建复制构造和重载=，导致类的浅复制，出现很多bug（值很随机）。最后查了好多遍才想到是那里的问题，不过搞完之后对这方面了解更多点了，嘿嘿！

题目：

1.稀疏矩阵乘法

•题意：两个n*n的矩阵相乘(n<=800)，结果对3取模（hdu4920）
•思路：先对3取模，所以两个矩阵里面会出现很多0，所以可以先枚举一个矩阵，只有当该位置不是0的时候才和另一个矩阵做乘法,我还用了一下输入挂。 
#include <iostream>
#include <cstdio>
#include <cstdlib>
typedef long long ll;
#define foreach(it,v) for(__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
using namespace std;
int mod = 3;
const int buf_len = 4096;
char buf[buf_len], *bufb(buf), *bufe(buf + 1);
int E = 1;
#define readBuf() { \
    if (++ bufb == bufe) \
        bufe = (bufb = buf) + (E=fread(buf, 1, sizeof(buf), stdin)); \
    if(!E)return 0; \
}
#define readInt(_y_) { \
    register int _s_(0); \
    do { \
        readBuf(); \
    } while (!isdigit(*bufb)); \
    do { \
        _s_ = (_s_<<1) + (_s_<<3) + *bufb - '0'; \
        readBuf(); \
    } while (isdigit(*bufb)); \
    _y_ = _s_; \
}
template <typename T> struct Matrix
{
	T ** base;
	int row,colnum;
	Matrix(int n = 0,int m = 0):row(n),colnum(m) {
		base = new T * [n];
		for(int i = 0; i < n; i++)
			base[i] = new T [m];
	}
	Matrix (const Matrix<T> & A) {
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	Matrix operator + (const Matrix <T> &A)const{
		Matrix<T> res(row,colnum);
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++) {
				res.base[i][j] = base[i][j] + A.base[i][j];
				if(mod)res.base[i][j] %= mod;
			}
		}
		return res;
	}
	void operator = (const Matrix<T> & A) {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	T * operator [] (const int & i) {
		return base[i];
	}
	void setv(const T & val) {
		for(int i = 0; i < row; i++)
			for(int j = 0; j < colnum; j++)
				base[i][j] = val;
	}
	Matrix ones(int n) const{
		Matrix<T> res(n,n);
		for(int i = 0; i < n; i++)
			for(int j = 0; j < n; j++)
				res.base[i][j] = (T)(i==j);
		return res;
	}
	Matrix operator * (const Matrix<T> & rhs) const {
		if(colnum != rhs.row) {
			cerr<<"worng size of two Matrix"<<endl;
			exit(-1);
		}
		Matrix<T> c(row,rhs.colnum);
		c.setv(T(0));
		for(int k = 0; k < colnum; k++) {
			for(int i = 0; i < row; i++) {
				T r = base[i][k];
				if(!r)continue;
				for(int j = 0; j < c.colnum; j++) {
					c[i][j] += r*rhs.base[k][j];
					if(mod)c[i][j] %= mod;
				}
			}
		}
		return c;
	}
	Matrix exp(int n) const{
		if(row!=colnum) {
			cerr<<"can't exp on different row and colnum"<<endl;
			exit(-1);
		}
		Matrix<T>res = ones(row),b(*this);
		while(n > 0) {
			if(n & 1)res = res * b;
			b = (b * b);
			n >>= 1;
		}
		return res;
	}
	void debug()const{
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++)
				cout<<base[i][j]<<" \n"[j+1==colnum];
		}
	}
	~Matrix() {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
	}
};
int main(int argc, char const *argv[])
{
	while(1) {
		int n;readInt(n);
		Matrix<int> A(n,n),B(n,n);
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				readInt(A[i][j]);
				A[i][j] %= 3;
			}
		}
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				readInt(B[i][j]);
				B[i][j] %= 3;
			}
		}
		(A*B).debug();
	}
	return 0;
}

• uva10655 给三个非负整数p,q,n，求a^n+b^n，其中a+b=p,ab=q(保证结果在10^18以内)
•解决思路：从a^n+b^n入手构造递推关系而且只用p,q表示，手算几项之后会发现f[n] = f[n-1]*p - f[n-2]*q,构造下矩阵然后快速幂。 
#include <bits/stdc++.h>
typedef long long ll;
#define foreach(it,v) for(__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
using namespace std;
const int maxn = 2e5 + 10;
ll mod = 0;
template <typename T> struct Matrix
{
	T ** base;
	int row,colnum;
	Matrix(int n = 0,int m = 0):row(n),colnum(m) {
		base = new T * [n];
		for(int i = 0; i < n; i++)
			base[i] = new T [m];
	}
	Matrix (const Matrix<T> & A) {
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	void operator = (const Matrix<T> & A) {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	T * operator [] (const int & i) {
		return base[i];
	}
	void setv(const T & val) {
		for(int i = 0; i < row; i++)
			for(int j = 0; j < colnum; j++)
				base[i][j] = val;
	}
	Matrix operator * (const Matrix<T> & rhs) const {
		if(colnum != rhs.row) {
			cerr<<"worng size of two Matrix"<<endl;
			exit(-1);
		}
		Matrix<T> c(row,rhs.colnum);
		c.setv(T(0));
		for(int k = 0; k < colnum; k++) {
			for(int i = 0; i < row; i++) {
				T r = base[i][k];
				for(int j = 0; j < c.colnum; j++) {
					c[i][j] += r*rhs.base[k][j];
					if(mod)c[i][j] %= mod;
				}
			}
		}
		return c;
	}
	Matrix exp(int n) {
		if(row!=colnum) {
			cerr<<"can't exp on different row and colnum"<<endl;
			exit(-1);
		}
		Matrix<T>res(row,colnum),b(*this);
		res.setv(T(0));
		for(int i = 0; i < row; i++) res.base[i][i] = T(1);
		while(n > 0) {
			if(n & 1)res = res * b;
			b = (b * b);
			n >>= 1;
		}
		return res;
	}
	void debug() {
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++)
				cout<<base[i][j]<<" \n"[j+1==colnum];
		}
	}
	~Matrix() {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
	}
};
int main(int argc, char const *argv[])
{
	int p,q,n;
	while(scanf("%d%d%d",&p,&q,&n)==3) {
		if(n==0)puts("2");
		else {
			Matrix<ll> A(1,2);
			A[0][0] = p;A[0][1] = 2;
			Matrix<ll> B(2,2);
			B[0][0] = p;B[0][1] = 1;
			B[1][0] = -q; B[1][1] = 0;
			printf("%lld\n", (A*B.exp(n-1))[0][0]);
		}
	}
	return 0;
}

• poj3233 A是一个n*n矩阵，求S = （A + A^2 + A^3 +… + A^k）%m,n<30,k<10^9
思路：矩阵快速幂加二分。如果我们求出了x = A+A^2+...A^(k/2),那么y = A^(k/2+1)+A^(k/2+2)+...A^k，可以由x的乘A^
(k/2) + {A^k|(当k为奇数时才需要}； 
#include <iostream>
#include <cstdio>
#include <cstdlib>
typedef long long ll;
#define foreach(it,v) for(__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
using namespace std;
const int maxn = 2e5 + 10;
int mod = 0;
template <typename T> struct Matrix
{
	T ** base;
	int row,colnum;
	Matrix(int n = 0,int m = 0):row(n),colnum(m) {
		base = new T * [n];
		for(int i = 0; i < n; i++)
			base[i] = new T [m];
	}
	Matrix (const Matrix<T> & A) {
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	Matrix operator + (const Matrix <T> &A)const{
		Matrix<T> res(row,colnum);
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++) {
				res.base[i][j] = base[i][j] + A.base[i][j];
				if(mod)res.base[i][j] %= mod;
			}
		}
		return res;
	}
	void operator = (const Matrix<T> & A) {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	T * operator [] (const int & i) {
		return base[i];
	}
	void setv(const T & val) {
		for(int i = 0; i < row; i++)
			for(int j = 0; j < colnum; j++)
				base[i][j] = val;
	}
	Matrix ones(int n) const{
		Matrix<T> res(n,n);
		for(int i = 0; i < n; i++)
			for(int j = 0; j < n; j++)
				res.base[i][j] = (T)(i==j);
		return res;
	}
	Matrix operator * (const Matrix<T> & rhs) const {
		if(colnum != rhs.row) {
			cerr<<"worng size of two Matrix"<<endl;
			exit(-1);
		}
		Matrix<T> c(row,rhs.colnum);
		c.setv(T(0));
		for(int k = 0; k < colnum; k++) {
			for(int i = 0; i < row; i++) {
				T r = base[i][k];
				if(!r)continue;
				for(int j = 0; j < c.colnum; j++) {
					c[i][j] += r*rhs.base[k][j];
					if(mod)c[i][j] %= mod;
				}
			}
		}
		return c;
	}
	Matrix exp(int n) const{
		if(row!=colnum) {
			cerr<<"can't exp on different row and colnum"<<endl;
			exit(-1);
		}
		Matrix<T>res = ones(row),b(*this);
		while(n > 0) {
			if(n & 1)res = res * b;
			b = (b * b);
			n >>= 1;
		}
		return res;
	}
	void debug()const{
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++)
				cout<<base[i][j]<<" \n"[j+1==colnum];
		}
	}
	~Matrix() {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
	}
};
template<typename T>Matrix<T> gao(const Matrix<T> &A,int k) {
	if(k==0)return A.ones(A.row);
	if(k==1)return A;
	Matrix<T> c = gao(A,k>>1);
	Matrix<T> t = A.exp(k>>1);
	c = c + c*t;
	if(k&1)c = c + t*t*A;
	return c;
}
int main(int argc, char const *argv[])
{
	int n,k;
	while(scanf("%d%d%d",&n,&k,&mod)==3) {
		Matrix<int>A(n,n);
		for(int i = 0; i < A.row; i++)
			for(int j = 0; j < A.colnum; j++)
				scanf("%d",&A[i][j]);
		(gao(A,k)).debug();
	}
	return 0;
}
• hdu1588 f(0)=0  f(1)=1  f(n)=f(n-1)+f(n-2) (n>=2),g(i)=k*i+b ，给定k,b,n,求sigma(f(g(i))(0<=i<=n)
•(k,b,n<=1,000,000,000,有取模）
因为g是一个等差数列，所以f是个f(g)是个等比矩阵。和上题思路一样，对公比的幂求和之后乘上初始值 
#include <iostream>
#include <cstdio>
#include <cstdlib>
typedef long long ll;
#define foreach(it,v) for(__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
using namespace std;
const int maxn = 2e5 + 10;
ll mod = 0;
template <typename T> struct Matrix
{
	T ** base;
	int row,colnum;
	Matrix(int n = 0,int m = 0):row(n),colnum(m) {
		base = new T * [n];
		for(int i = 0; i < n; i++)
			base[i] = new T [m];
	}
	Matrix (const Matrix<T> & A) {
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	Matrix operator + (const Matrix <T> &A)const{
		Matrix<T> res(row,colnum);
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++) {
				res.base[i][j] = base[i][j] + A.base[i][j];
				if(mod)res.base[i][j] %= mod;
			}
		}
		return res;
	}
	void operator = (const Matrix<T> & A) {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	T * operator [] (const int & i) {
		return base[i];
	}
	void setv(const T & val) {
		for(int i = 0; i < row; i++)
			for(int j = 0; j < colnum; j++)
				base[i][j] = val;
	}
	Matrix ones(int n) const{
		Matrix<T> res(n,n);
		for(int i = 0; i < n; i++)
			for(int j = 0; j < n; j++)
				res.base[i][j] = (T)(i==j);
		return res;
	}
	Matrix operator * (const Matrix<T> & rhs) const {
		if(colnum != rhs.row) {
			cerr<<"worng size of two Matrix"<<endl;
			exit(-1);
		}
		Matrix<T> c(row,rhs.colnum);
		c.setv((T)0);
		for(int k = 0; k < colnum; k++) {
			for(int i = 0; i < row; i++) {
				T r = base[i][k];
				if(!r)continue;
				for(int j = 0; j < c.colnum; j++) {
					c[i][j] += r*rhs.base[k][j];
					if(mod)c[i][j] %= mod;
				}
			}
		}
		return c;
	}
	Matrix exp(int n) const{
		if(row!=colnum) {
			cerr<<"can't exp on different row and colnum"<<endl;
			exit(-1);
		}
		Matrix<T>res = ones(row),b(*this);
		while(n > 0) {
			if(n & 1)res = res * b;
			b = (b * b);
			n >>= 1;
		}
		return res;
	}
	void debug()const{
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++)
				cout<<base[i][j]<<" \n"[j+1==colnum];
		}
	}
	~Matrix() {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
	}
};
template<typename T>Matrix<T> gao(const Matrix<T> &A,int k) {
	if(k==0)return A.ones(A.row);
	if(k==1)return A;
	Matrix<T> c = gao(A,k>>1);
	Matrix<T> t = A.exp(k>>1);
	c = c + c*t;
	if(k&1)c = c + t*t*A;
	return c;
}
int main(int argc, char const *argv[])
{
	int n,k,b;
	Matrix<ll> a0(1,2);
	a0[0][0] = 1; a0[0][1] = 0;
	Matrix<ll> q0(2,2); q0.setv(1);
	q0[1][1] = 0;
	while(scanf("%d%d%d%I64d",&k,&b,&n,&mod)==4) {
		Matrix<ll> A = a0*(q0.exp(b));
		Matrix<ll> Q = q0.exp(k);
		if(n==1) printf("%I64d\n", A[0][1]);
		else {
			printf("%I64d\n",(A*(Q.ones(Q.row) + gao(Q,n-1)))[0][1]);
		}
	}
	return 0;
}

•题意：给出n，求   (n<=10^9)
•
•F(k)是标准fibonacci数列，C(n,k)是组合数
•结果对1e9+7取模
打表之后发现结果是F(2n)。证明如下 




#include <iostream>
#include <cstdio>
#include <cstdlib>
typedef long long ll;
#define foreach(it,v) for(__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
using namespace std;
const int maxn = 2e5 + 10;
ll mod = 0;
template <typename T> struct Matrix
{
	T ** base;
	int row,colnum;
	Matrix(int n = 0,int m = 0):row(n),colnum(m) {
		base = new T * [n];
		for(int i = 0; i < n; i++)
			base[i] = new T [m];
	}
	Matrix (const Matrix<T> & A) {
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	Matrix operator + (const Matrix <T> &A)const{
		Matrix<T> res(row,colnum);
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++) {
				res.base[i][j] = base[i][j] + A.base[i][j];
				if(mod)res.base[i][j] %= mod;
			}
		}
		return res;
	}
	void operator = (const Matrix<T> & A) {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	T * operator [] (const int & i) {
		return base[i];
	}
	void setv(const T & val) {
		for(int i = 0; i < row; i++)
			for(int j = 0; j < colnum; j++)
				base[i][j] = val;
	}
	Matrix ones(int n) const{
		Matrix<T> res(n,n);
		for(int i = 0; i < n; i++)
			for(int j = 0; j < n; j++)
				res.base[i][j] = (T)(i==j);
		return res;
	}
	Matrix operator * (const Matrix<T> & rhs) const {
		if(colnum != rhs.row) {
			cerr<<"worng size of two Matrix"<<endl;
			exit(-1);
		}
		Matrix<T> c(row,rhs.colnum);
		c.setv((T)0);
		for(int k = 0; k < colnum; k++) {
			for(int i = 0; i < row; i++) {
				T r = base[i][k];
				if(!r)continue;
				for(int j = 0; j < c.colnum; j++) {
					c[i][j] += r*rhs.base[k][j];
					if(mod)c[i][j] %= mod;
				}
			}
		}
		return c;
	}
	Matrix exp(int n) const{
		if(row!=colnum) {
			cerr<<"can't exp on different row and colnum"<<endl;
			exit(-1);
		}
		Matrix<T>res = ones(row),b(*this);
		while(n > 0) {
			if(n & 1)res = res * b;
			b = (b * b);
			n >>= 1;
		}
		return res;
	}
	void debug()const{
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++)
				cout<<base[i][j]<<" \n"[j+1==colnum];
		}
	}
	~Matrix() {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
	}
};
template<typename T>Matrix<T> gao(const Matrix<T> &A,int k) {
	if(k==0)return A.ones(A.row);
	if(k==1)return A;
	Matrix<T> c = gao(A,k>>1);
	Matrix<T> t = A.exp(k>>1);
	c = c + c*t;
	if(k&1)c = c + t*t*A;
	return c;
}
int main(int argc, char const *argv[])
{
	int n,k,b;
	Matrix<int> a0(1,2);
	a0[0][0] = 1; a0[0][1] = 0;
	Matrix<int> q0(2,2); q0.setv(1);
	q0[1][1] = 0;
	int T;scanf("%d",&T);
	while(T--) {
		int n;scanf("%d%I64d",&n,&mod);
		printf("%d\n",(a0*(q0.exp(2*n)))[0][1]);
	}
	return 0;
}



hdu 2157给出一个n个点，m条边的有向图，T次询问，每次输入a，b，k问从a到b经过k个点的方案是多少，直接快速幂。输出 

#include <iostream>
#include <cstdio>
#include <cstdlib>
typedef long long ll;
#define foreach(it,v) for(__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
using namespace std;
const int maxn = 2e5 + 10;
ll mod = 0;
template <typename T> struct Matrix
{
	T ** base;
	int row,colnum;
	Matrix(int n = 0,int m = 0):row(n),colnum(m) {
		base = new T * [n];
		for(int i = 0; i < n; i++)
			base[i] = new T [m];
	}
	Matrix (const Matrix<T> & A) {
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	Matrix operator + (const Matrix <T> &A)const{
		Matrix<T> res(row,colnum);
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++) {
				res.base[i][j] = base[i][j] + A.base[i][j];
				if(mod)res.base[i][j] %= mod;
			}
		}
		return res;
	}
	void operator = (const Matrix<T> & A) {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	T * operator [] (const int & i) {
		return base[i];
	}
	void setv(const T & val) {
		for(int i = 0; i < row; i++)
			for(int j = 0; j < colnum; j++)
				base[i][j] = val;
	}
	Matrix ones(int n) const{
		Matrix<T> res(n,n);
		for(int i = 0; i < n; i++)
			for(int j = 0; j < n; j++)
				res.base[i][j] = (T)(i==j);
		return res;
	}
	Matrix operator * (const Matrix<T> & rhs) const {
		if(colnum != rhs.row) {
			cerr<<"worng size of two Matrix"<<endl;
			exit(-1);
		}
		Matrix<T> c(row,rhs.colnum);
		c.setv((T)0);
		for(int k = 0; k < colnum; k++) {
			for(int i = 0; i < row; i++) {
				T r = base[i][k];
				if(!r)continue;
				for(int j = 0; j < c.colnum; j++) {
					c[i][j] += r*rhs.base[k][j];
					if(mod)c[i][j] %= mod;
				}
			}
		}
		return c;
	}
	Matrix exp(int n) const{
		if(row!=colnum) {
			cerr<<"can't exp on different row and colnum"<<endl;
			exit(-1);
		}
		Matrix<T>res = ones(row),b(*this);
		while(n > 0) {
			if(n & 1)res = res * b;
			b = (b * b);
			n >>= 1;
		}
		return res;
	}
	void debug()const{
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++)
				cout<<base[i][j]<<" \n"[j+1==colnum];
		}
	}
	~Matrix() {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
	}
};
int main(int argc, char const *argv[])
{
	int n,m;
	mod = 1000;
	while(scanf("%d%d",&n,&m)==2) {
		if(n+m==0)return 0;
		Matrix<int> A(n,n);
		A.setv(0);
		while(m--) {
			int u,v;scanf("%d%d",&u,&v);
			A[u][v] = 1;
		}
		int T;scanf("%d",&T);
		while(T--) {
			int s,t,k; scanf("%d%d%d",&s,&t,&k);
			printf("%d\n",A.exp(k)[s][t]);
		}
	}
	return 0;
}

FZU 2173  给出一个n个点，H条边的有向图，还有输入的k，经过一条边需要1s，有一个花费w，问从1到n恰好k秒的最小花费是多少，其实就是跑k遍floyd，可以用矩阵快速幂加速一下，乘法换加法就ok，这题没用模板写 
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
typedef long long ll;
const ll inf = 1e17 + 10;
#define Type ll
#define SIZER 50
#define SIZEC 50
#define foreach(it,v) for(__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
using namespace std;
int mod = 0;
const int maxn = 5000000 + 4;
struct Matrix
{
	Type a[SIZER][SIZEC];
	int row,colunm;
	Matrix(int n = 1,int m = 1):row(n),colunm(m){}
	bool samerc(const Matrix & rhs) const{
		return rhs.row == row && rhs.colunm == colunm;
	}
	bool canmul(const Matrix & rhs) const{
		return colunm == rhs.row;
	}
	Matrix operator + (const Matrix & rhs) const{
		if(!samerc(rhs)) {
			puts("size Dont match");
			exit(-1);
		}
		Matrix c(row,colunm);
		for(int i = 0; i < row; i++)
			for(int j = 0; j < colunm; j++) {
				c.a[i][j] = a[i][j] + rhs.a[i][j];
				if(mod) c.a[i][j] %= mod;
			}
		return c;
	}
	void one() {
		for(int i = 0; i < row; i++)
			for(int j = 0; j < colunm; j++)
				a[i][j] = (i==j);
	}
	void debug() {
		for(int i = 0; i < row; i++)
			for(int j = 0; j < colunm; j++)
				cout<<a[i][j]<<" \n"[j+1==colunm];
	}
	void Zero() { memset(a,0,sizeof a); }
	Matrix operator * (const Matrix & rhs) const{
		if(!canmul(rhs)) {
			puts("can't mul Matrix with wrong size");
			exit(-1);
		}
		Matrix c(row,rhs.colunm);
		for(int i = 0; i < c.row; i++) {
			for(int j = 0; j < c.colunm; j++) {
				c.a[i][j] = inf;
			}
		}
		for(int i = 0; i < row; i++)
			for(int j = 0; j < rhs.colunm; j++)
				for(int k = 0; k < colunm; k++)
					c.a[i][j] = min(c.a[i][j],a[i][k] + rhs.a[k][j]);
		return c;
	}
};
Matrix quick_exp(const Matrix & A,int k)
{
	Matrix res = A,b = A;
	k--;
	while(k > 0) {
		if(k&1)res = res * b;
		k >>= 1;
		b = b*b;
	}
	return res;
}
int main()
{
	int T;scanf("%d",&T);
	while(T--) {
		ll n,h,k;scanf("%I64d%I64d%I64d",&n,&h,&k);
		Matrix A(n,n);
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				A.a[i][j] = inf;
			}
		}
		while(h--) {
			ll u,v,w;scanf("%I64d%I64d%I64d",&u,&v,&w);
			u--,v--;
			A.a[u][v] = min(A.a[u][v],w);
		}
		ll ans = quick_exp(A,k).a[0][n-1];
		if(ans>= inf) ans = -1;
		printf("%I64d\n",ans);
	}
	return 0;
}

未能AC  POJ3150
•一个n个位置的环，每个数范围是0~m-1,有一种操作，每次操作中每个位置的值变成距离d以内（包括本身）的和模m，问k次操作后每个位置的值 

#include <iostream>
#include <cstdio>
#include <cstdlib>
typedef long long ll;
#define foreach(it,v) for(__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
using namespace std;
int mod;
template <typename T> struct Matrix
{
	T ** base;
	int row,colnum;
	Matrix(int n = 0,int m = 0):row(n),colnum(m) {
		base = new T * [n];
		for(int i = 0; i < n; i++)
			base[i] = new T [m];
	}
	Matrix (const Matrix<T> & A) {
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	Matrix operator + (const Matrix <T> &A)const{
		Matrix<T> res(row,colnum);
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++) {
				res.base[i][j] = base[i][j] + A.base[i][j];
				if(mod)res.base[i][j] %= mod;
			}
		}
		return res;
	}
	void operator = (const Matrix<T> & A) {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
		row = A.row;
		colnum = A.colnum;
		base = new T *[row];
		for(int i = 0; i < row; i++) {
			base[i] = new T [colnum];
			for(int j = 0; j < colnum; j++)
				base[i][j] = A.base[i][j];
		}
	}
	T * operator [] (const int & i) const {
		return base[i];
	}
	void setv(const T & val) {
		for(int i = 0; i < row; i++)
			for(int j = 0; j < colnum; j++)
				base[i][j] = val;
	}
	Matrix ones(int n) const{
		Matrix<T> res(n,n);
		for(int i = 0; i < n; i++)
			for(int j = 0; j < n; j++)
				res.base[i][j] = (T)(i==j);
		return res;
	}
	Matrix operator * (const Matrix<T> & rhs) const {
		if(colnum != rhs.row) {
			cerr<<"worng size of two Matrix"<<endl;
			exit(-1);
		}
		Matrix<T> c(row,rhs.colnum);
		c.setv(T(0));
		for(int k = 0; k < colnum; k++) {
			for(int i = 0; i < row; i++) {
				T r = base[i][k];
				if(!r)continue;
				for(int j = 0; j < c.colnum; j++) {
					c[i][j] += r*rhs.base[k][j];
					if(mod)c[i][j] %= mod;
				}
			}
		}
		return c;
	}
	Matrix exp(int n) const{
		if(row!=colnum) {
			cerr<<"can't exp on different row and colnum"<<endl;
			exit(-1);
		}
		Matrix<T>res = ones(row),b(*this);
		while(n > 0) {
			if(n & 1)res = res * b;
			b = (b * b);
			n >>= 1;
		}
		return res;
	}
	void debug()const{
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < colnum; j++)
				cout<<base[i][j]<<" \n"[j+1==colnum];
		}
	}
	~Matrix() {
		for(int i = 0; i < row; i++) delete [] base[i];
		delete [] base;
	}
};
void gao(Matrix<ll> &A) {
	int sz = A.colnum;
	ll t = A[0][sz-1];
	for(int i = sz-1; i > 0; i--) A[0][i] = A[0][i-1];
	A[0][0] = t;
}
Matrix<ll> mul(Matrix<ll> &A,Matrix<ll> &B) {

	Matrix<ll> c(1,B.colnum);
	c.setv(0);
	for(int k = 0; k < A.colnum; k++) {
		ll r = A[0][k];
		for(int j = 0; j < B.colnum; j++) {
			c[0][j] += r*B[k][j];
			if(mod) c[0][j] %= mod;
		}
	}
	for(int i = 0; i < B.row; i++) {
		for(int j = 0; j < B.colnum; j++)B[i][j] = c[0][j];
		gao(c);
	}
	return B;
}
Matrix<ll> exp(Matrix<ll> &A,int k)
{
	Matrix<ll> res = A.ones(A.row),base(A);
	while(k > 0) {
		if(k&1)res = mul(res,base);
		base = mul(base,base);
		k >>= 1;
	}
	return res;
}
int main(int argc, char const *argv[])
{
	int n,d,k;
	while(scanf("%d%d%d%d",&n,&mod,&d,&k)==4) {
		Matrix<ll> A(n,1);
		Matrix<ll> B(n,n);
		B.setv(0);
		for(int i = 0; i <n ; i++) {
			B[i][i] = 1;
			for(int j = 1; j <= d; j++) {
				B[i][(i+j)%n] = 1;
				B[i][(i-j+n)%n] = 1;
			}
		}
		for(int i = 0; i < n; i++) {
			scanf("%I64d",&A[i][0]);
		}
		B = exp(B,k);
		Matrix<ll> res(B*A);
		for(int i = 0; i < n; i++) {
			if(i)putchar(' ');
			printf("%I64d", res[i][0]);
		}
		putchar('\n');
	}
	return 0;
}

akxxsb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
矩阵总结
m0_37957160的博客
07-03 311
对称矩阵 满足A=的矩阵，称为对称矩阵。（=意思就是里边的每一个元素都想等）性质如下： 对称矩阵的特征值一定是实数。 对称矩阵的几何重数等于代数重数。（？？？） 对称矩阵一定有n个线性无关的特征向量。（此处的n就是矩阵中的nxn？？？） 对称矩阵一定可以对角化。（对角化） 对称矩阵可以正交对角化。（正交对角化） ...
[数学]矩阵总结
一瓶93年的葡萄酒
01-09 559
1.学习资料:  2. 矩阵最常见的5个作用 1. 求线性递推第n项   (POJ  3070 HDU 1757) 2. 已经线性递推式,求递推式中任意区间内的和,解这类题目有2种方法    (POJ 3233 非常经典的一题) a) 递推式中的每一项相当于一个矩阵幂，求项和就相当于求矩阵幂和，而求矩阵幂和，又可以2分   (HDU 1588) b) 在矩阵上加上一维
矩阵小结，矩阵及其运算，各矩阵的名称
06-03
矩阵是线性代数中的基本概念，用于组织和操作数据，尤其在计算机科学、工程、数学和物理等领域中有着广泛的应用。以下是对矩阵及其运算的详细总结： 1. **矩阵的定义**： 矩阵是由m行n列的数字（实数或复数）组成...
常用向量与矩阵微分小结1
最新发布
08-03
在机器学习和数值分析中，向量和矩阵的微分是至关重要的概念，尤其是在优化算法和深度学习模型的训练过程中。向量与矩阵微分的理解和应用能够帮助我们有效地理解和解决复杂的数学问题，例如梯度下降和反向传播。本文...
Python中的几种矩阵乘法（小结）
12-25
对二维矩阵，计算真正意义上的矩阵乘积。 对于一维矩阵，计算两者的内积。 2.代码  【code】 import numpy as np # 2-D array: 2 x 3 two_dim_matrix_one = np.array([[1, 2, 3], [4, 5, 6]]) # 2-D array: 3 x ...
python的常见矩阵运算(小结)
12-25
python的numpy库提供矩阵运算的功能，因此我们在需要矩阵运算的时候，需要导入numpy的包。 1.numpy的导入和使用 from numpy import *;#导入numpy的库函数 import numpy as np; #这个方式使用numpy的函数时，需要以...
Python 矩阵转置的几种方法小结
09-18
对于小规模矩阵或学习理解矩阵转置原理，前两种方法更为直观；而对于大规模矩阵或在进行大量矩阵运算的项目中，使用`numpy`库将带来更高的效率和便利性。 总的来说，Python提供了多种灵活的方式来实现矩阵转置，这...
矩阵类设计
xunmeng2002的专栏
03-24 1887
用C++类封装了一个矩阵的类，实现了加、减和乘法的运算符重载，同时复习了一遍拷贝、移动等构造函数和赋值运算符的重载。 Matrix.h #pragma once #include <stdio.h> #include <iostream> template<typename T> class Matrix { public: Matrix() { Row = Column = 0; Item = nullptr; } Matrix(int row,
数学中的各种矩阵大总结
白马负金羁
07-04 5万+
作为线性代数的重要研究内容，矩阵在图像处理等领域也有着非常重要的应用价值。很多特殊矩阵，常常令人眼花缭乱，例如：Toeplitz 矩阵、Hermitian 矩阵、Circulant 矩阵、Unitary 矩阵、Hessian 矩阵、Vandermonde 矩阵和Fourier矩阵等。本文将一一解析这些特殊矩阵，并在最后讨论循环矩阵的傅里叶对角化问题，这也是图像处理与机器视觉中一个应用广泛的数学知识
关于C++ const 的全面总结
pengjin1985的专栏
06-19 421
C++中的const关键字的用法非常灵活，而使用const将大大改善程序的健壮性，本人根据各方面查到的资料进行总结如下，期望对朋友们有所帮助。 Const 是C++中常用的类型修饰符,常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。   一、Const作用    如下表所示： No. 作用 说明 参考代码
const的几种使用方法
firefly_2002的专栏
10-07 2万+
const 的使用 const经常用来修饰一个值不能改变的量，安全，并且能消除存储操作(在存储时只存一次) const的几种用法： （1）      说明值常量 （2）      说明指针 （3）      说明函数参数及其返回值 （4）      说明类的常量和成员函数   const 说明值常量 值常量的说明一般放在头文件或者文件的开始部分，也可以放在类中进行说明 （1）
C语言中const关键字的用法
热门推荐
xingjiarong的专栏
08-09 24万+
关键字const用来定义常量，如果一个变量被const修饰，那么它的值就不能再被改变，我想一定有人有这样的疑问，C语言中不是有#define吗，干嘛还要用const呢，我想事物的存在一定有它自己的道理，所以说const的存在一定有它的合理性，与预编译指令相比，const修饰符有以下的优点： 1、预编译指令只是对值进行简单的替换，不能进行类型检查 2、可以保护被修饰的东西，防止意外修改，增强程序
矩阵期望 matlab,matlab中矩阵元素求和、求期望和均方差
weixin_32816821的博客
03-19 6213
在matlab中求一个矩阵中元素的和可以自己编写for循环来完成，这样比较方便，想求那些数据的和都可以做到，然而效率比较低，如果数据量大程序会跑好长时间。所以我们可以转而用matlab提供的sum函数。设M为一个矩阵，那么：1、求和sum(M):以矩阵M的每一列为对象，对每一列的数据分别求和。sum(M,2):以矩阵的每一行为对象，对每一行的数据分别求和。sum(M(：))：将矩阵中的所有元素相加...
期望
liulang的专栏
11-21 590
期              望
2018.10.25【NOIP练习】01矩阵（组合数学）（数学期望）
zxyoi_dreamer的博客（不定期诈尸）
10-25 1914
传送门 解析： 请先确保你看懂了OJ上的提示的暴力做法再来看这个题解。 既然你已经会暴力了，那进入正题。 实际上我们就没有必要计算每个矩阵并求和，我们只需要枚举每个iii并计算min{Bi}=imin\{B_i\}=imin{Bi​}=i的矩阵有多少个就行了。 现在考虑令矩阵一行的和为iii的方案数fif_ifi​，显然fi=Cmi×xm−i×yif_i=C_m^i\times x^{m-i}\...
多视几何_计算两幅图像之间的基础矩阵F和一副图像上的点在另一福图像上的极线L
惊鸿一博
12-19 679
功能说明: 输入两帧图像的相对变换Tji =(R,t) (从图像i变换到图像j), 相机的内参K (假设两幅图像使用的相机是同一个), 输入图像i中的点m 输出: 计算图像i的m点, 在图像j上的极线L = (a,b,c), (则图像j上的极线方程为 ax + by +c = 0) 实现: def calculate_epipolar_line (K, Tji, m): """ calculate the epipolar line for point m Args:
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值