矩阵经典操作（4）

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

这是关于斐波拉切的经典操作

POJ3070

这是关于斐波拉切数列用矩阵表示的最基本的题，正如题目描述的那样，f[i]=A^i.a[0][1]，在这儿A为固定矩阵

       |   1     1 |

A = |              |

      |    1     0 |

#include<iostream>
#include<iomanip>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<climits>
#define maxn 10000
#define mod 10000
using namespace std;

struct matrix
{
    int a[2][2];
    void clear()
    {
        memset(a,0,sizeof(a));
    }

    void init()
    {
        a[0][0]=1;
        a[0][1]=1;
        a[1][0]=1;
        a[1][1]=0;
    }

    matrix operator +(const matrix &b)const
    {
        matrix c;
        c.clear();
        for(int i=0; i<2; i++)
        {
            for(int j=0; j<2; j++)
            {
                c.a[i][j]=a[i][j]+b.a[i][j];
            }
        }
        return c;
    }

    matrix operator *(const matrix b)const
    {
        matrix c;
        c.clear();
        for(int i=0; i<2; i++)
        {
            for(int j=0; j<2; j++)
            {
                for(int k=0; k<2; k++)
                {
                    c.a[i][j]+=a[i][k]*b.a[k][j];
                }
                c.a[i][j]=c.a[i][j]%mod;
            }
        }
        return c;
    }
};

matrix pow(matrix a,int b)
{
    matrix per;
    per.init();
    while(b)
    {
        if(b&1)
        {
            per=per*a;
        }
        a=a*a;
        b>>=1;
    }
    return per;
}


int main()
{
    //freopen("C:\\Users\\Administrator\\Desktop\\in.txt" , "r" , stdin);
    int n;
    matrix a,ans;
    a.init();
    while(cin>>n)
    {
        if(n==-1)break;
        if(n==0){puts("0");continue;}
        else
        {
            ans=pow(a,n-1);
            cout<<(ans.a[0][1])%mod<<endl;
        }
    }
    return 0;
}

HDU3306

/*************************
http://acm.hdu.edu.cn/showproblem.php?pid=3306

题意：Fibonacci : A(0) = 1 , A(1) = 1 , A(N) = X * A(N - 1) + Y * A(N - 2) (N >= 2).
计算A(0)^2+……A(N)^2

思路：构造矩阵  矩阵如下
|1 x^2 y^2 2xy|   |  S(N-1)    |   |  S(N)    |
|0 x^2 y^2 2xy| * |  A(N-1)^2  | = |  A(N)^2  |
|0  1   0   0 |   |  A(N-2)^2  |   |  A(N-1)^2|
|0  x   0   y |   |A(N-1)A(N-2)|   |A(N)A(N-1)|
*************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define mod 10007
using namespace std;

int t,x,y;
struct matrix
{
    int n,m;
    int a[5][5];

    void clear()
    {
        m=n=0;
        memset(a,0,sizeof(a));
    }

    matrix operator +(const matrix &b)const
    {
        matrix c;
        c.clear();
        c.n=n,c.m=m;

        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)
            {
                c.a[i][j]=(a[i][j]+b.a[i][j])%mod;
            }
        }
        return c;
    }

    matrix operator *(const matrix &b)const
    {
        matrix c;
        c.clear();
        c.n=n,c.m=b.m;

        for(int i=0; i<n; i++)
        {
            for(int j=0; j<b.m; j++)
            {
                for(int k=0; k<m; k++)
                {
                    c.a[i][j]+=a[i][k]*b.a[k][j];
                }
                c.a[i][j]%=mod;
            }
        }
        return c;
    }
};

matrix pow(matrix a,int b)
{
    matrix ans;
    ans.clear();
    ans.n=ans.m=a.n;
    for(int i=0; i<a.n; i++)
    {
        ans.a[i][i]=1;
    }

    while(b)
    {
        if(b&1)
        {
            ans=ans*a;
        }
        a=a*a;
        b>>=1;
    }
    return ans;
}

matrix a,b;
__int64 ans;
int main()
{
    while(~scanf("%d%d%d",&t,&x,&y))
    {
        x%=mod,y%=mod;
        if(t==0||t==1)
        {
            printf("1\n");
            continue;
        }
        a.clear();
        a.n=a.m=4;
        a.a[0][0]=a.a[2][1]=1;
        a.a[0][1]=a.a[1][1]=x*x%mod;
        a.a[0][2]=a.a[1][2]=y*y%mod;
        a.a[0][3]=a.a[1][3]=2*x*y%mod;
        a.a[3][1]=x;
        a.a[3][3]=y;

        b.clear();
        b.n=4,b.m=1;
        b.a[0][0]=2;
        b.a[1][0]=1;
        b.a[2][0]=1;
        b.a[3][0]=1;

        a=pow(a,t-1);
        a=a*b;
        ans=0;
        for(int i=0;i<4;i++)
        {
            ans+=a.a[0][i];
        }
        printf("%d\n",ans%mod);
    }
    return 0;
}
HDU4549 

/*************************
http://acm.hdu.edu.cn/showproblem.php?pid=4549

题意：
F[0] = a
F[1] = b
F[n] = F[n-1] * F[n-2] ( n > 1 )计算F[n]%1000000007

思路：矩阵构造+欧拉函数+整数快速幂+矩阵快速幂
通过对表达式的求解可以得到F[]的最终形式是对ab的斐波拉切数的乘积，
即F[i]=a^f[i-1]*b^f[i]
在这儿f[]表示最基本的菲波拉契数列，而关于菲波拉契数可以通过矩阵构造得到
此后可以通过整数快速幂来求解答案，只是注意矩阵乘法会溢出，即使%mod也会，因此要用到欧拉函数来优化
在欧拉函数中有这么一个定理

A^B%C=A^(B%phi(C)+phi(C))%C    B>=phi(C)
在这儿phi表示欧拉函数，而mod为素数，因此phi(C)=mod-1

这题贡献了无数次WA---主要数关于mod的问题

*************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define mod 1000000007
using namespace std;

__int64 x,y,t;
struct matrix
{
    int n,m;
    __int64 a[5][5];

    void clear()
    {
        m=n=0;
        memset(a,0,sizeof(a));
    }

    matrix operator +(const matrix &b)const
    {
        matrix c;
        c.clear();
        c.n=n,c.m=m;

        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)
            {
                c.a[i][j]=(a[i][j]+b.a[i][j])%(mod-1);
            }
        }
        return c;
    }

    matrix operator *(const matrix &b)const
    {
        matrix c;
        c.clear();
        c.n=n,c.m=b.m;

        for(int i=0; i<n; i++)
        {
            for(int j=0; j<b.m; j++)
            {
                for(int k=0; k<m; k++)
                {
                    c.a[i][j]+=a[i][k]*b.a[k][j];
                }
                c.a[i][j]%=(mod-1);
            }
        }
        return c;
    }
};
matrix mpow(matrix a,__int64 b)
{
    matrix ans;
    ans.clear();
    ans.n=ans.m=a.n;
    for(int i=0; i<a.n; i++)
    {
        ans.a[i][i]=1;
    }

    while(b)
    {
        if(b&1)
        {
            ans=ans*a;
        }
        a=a*a;
        b>>=1;
    }
    return ans;
}

__int64 pow(__int64 a,__int64 b)
{
    __int64 ans=1;
    a=a%mod;
    while(b)
    {
        if(b&1)
        {
            ans=ans*a%mod;
        }
        a=a*a%mod;
        b>>=1;
    }
    return ans;
}

void print(matrix a)
{
    for(int i=0; i<2; i++)
    {
        for(int j=0; j<2; j++)
        {
            cout<<a.a[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<"-----"<<endl;
}

matrix a;
__int64 ans;
__int64 t1,t2;
int main()
{
    while(~scanf("%I64d%I64d%I64d",&x,&y,&t))
    {
        if(t==0)
        {
            printf("%I64d\n",x);
            continue;
        }
        else if(t==1)
        {
            printf("%I64d\n",y);
            continue;
        }
        else
        {
            a.clear();
            a.n=a.m=2;
            a.a[0][0]=a.a[0][1]=a.a[1][0]=1;
            a.a[1][1]=0;
            a=mpow(a,t);
            //print(a);

            t1=a.a[1][1];
            t2=a.a[0][1];
            ans=0;
            ans=(pow(x,t1)*pow(y,t2))%mod;
            printf("%I64d\n",ans);
        }
    }
    return 0;
}

HDU3936 
/************************
http://acm.hdu.edu.cn/showproblem.php?pid=3936

题意：设定p[i]=f[i*4-1],给定一个区间，球在这个区间的p[i]的总和

思路：p[1] + p[2] + ... + p[n] = f[1]^2 + f[2]^2 + ... + f[2*n-1]^2 + f[2*n]^2 = f[2*n] * f[2*n+1]
这个题目比较蛋疼，谁会知道这么多的公式啊 ，不过知道这个公式后就简单了 

Fibonacci数列通项公式∴F(n)=(1/√5)*{[(1+√5)/2]^(n+1) - [(1-√5)/2]^(n+1)}
性质：
　　1.f(0)+f(1)+f(2)+…+f(n)=f(n+2)-1。 
　　2.f(1)+f(3)+f(5)+…+f(2n-1)=f(2n)。 
　　3.f(2)+f(4)+f(6)+…+f(2n) =f(2n+1)-1。 
　　4.[f(0)]^2+[f(1)]^2+…+[f(n)]^2=f(n)·f(n+1)。 
　　5.f(0)-f(1)+f(2)-…+(-1)^n·f(n)=(-1)^n·[f(n+1)-f(n)]+1。 
　　6.f(m+n-1)=f(m-1)·f(n-1)+f(m)·f(n)。 
        利用这一点，可以用程序编出时间复杂度仅为O（log n）的程序。 
　　7.[f(n)]^2=(-1)^(n-1)+f(n-1)·f(n+1)。 
　　8.f(2n-1)=[f(n)]^2-[f(n-2)]^2。 
　　9.3f(n)=f(n+2)+f(n-2)。 
　　10.f(2n-2m-2)[f(2n)+f(2n+2)]=f(2m+2)+f(4n-2m) [ n〉m≥-1,且n≥1] 
    11.f(2n+1)=[f(n)]^2+[f(n+1)]^2.
斐波那契数列的整除性与素数生成性
　　每3个数有且只有一个被2整除， 
　　每4个数有且只有一个被3整除, 
　　每5个数有且只有一个被5整除， 
　　每6个数有且只有一个被8整除, 
　　每7个数有且只有一个被13整除， 
　　每8个数有且只有一个被21整除, 
　　每9个数有且只有一个被34整除
************************/

#include<iostream>
#include<cstring>
#include<cstdio>
#define mod 1000000007
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;

struct matrix
{
    int n,m;
    __int64 a[5][5];

    void clear()
    {
        memset(a,0,sizeof(a));
    }

    matrix operator +(const matrix &b)const
    {
        matrix c;
        c.clear();
        c.n=n,c.m=m;

        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)
            {
                c.a[i][j]=(a[i][j]+b.a[i][j])%mod;
            }
        }
        return c;
    }

    matrix operator *(const matrix &b)const
    {
        matrix c;
        c.clear();
        c.n=n,c.m=b.m;

        for(int i=0; i<n; i++)
        {
            for(int j=0; j<b.m; j++)
            {
                for(int k=0; k<m; k++)
                {
                    c.a[i][j]+=a[i][k]*b.a[k][j];
                }
                c.a[i][j]%=mod;
            }
        }
        return c;
    }
};

matrix pow(matrix a,__int64 b)
{
    matrix ans;
    ans.clear();
    ans.n=ans.m=a.n;
    for(int i=0; i<a.n; i++)
    {
        ans.a[i][i]=1;
    }

    while(b)
    {
        if(b&1)
        {
            ans=ans*a;
        }
        a=a*a;
        b>>=1;
    }
    return ans;
}

int t;
__int64 l,r;
matrix a;
__int64 ans1,ans2;
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%I64d%I64d",&l,&r);
        a.clear();
        a.n=a.m=2;
        a.a[0][0]=a.a[0][1]=a.a[1][0]=1;
        a.a[1][1]=0;
        
        ans1=(pow(a,2*r).a[0][1]*pow(a,2*r+1).a[0][1])%mod;
        ans2=(pow(a,2*l-2).a[0][1]*pow(a,2*l-1).a[0][1])%mod;
        printf("%I64d\n",(ans1-ans2+mod)%mod);
    }
    return 0;
}

HDU1568

这不是矩阵的题目，但是是斐波拉契的题目，在这儿列出主要原因是因为它和HDU3177有相似点，都是取菲波拉契数的前几位或者后几位，对候几位数，直接可以取模运算，对于前几位就回归到斐波拉切的本质上来 ，通过位数公式就可以求得

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#define  mod 10000
using namespace std;

__int64 fib[50];
__int64 solve(__int64 n)
{
    double ans = -0.5 * log10(5.0) + n * log10((sqrt(5.0) + 1) / 2);
    __int64 d = (__int64)ans;
    ans -= d;
    ans = pow(10.0, ans);
    while(ans < 1000)
        ans *= 10;
    return (__int64)ans;
}

int main()
{
    freopen("C:\\Users\\Administrator\\Desktop\\in.txt" , "r" , stdin);
    int n;
    fib[0]=0;
    fib[1]=1;
    for(int i=2; i<40; i++)
    {
        fib[i]=fib[i-1]+fib[i-2];
    }
    while(~scanf("%I64d",&n))
    {
        if(n<=20)
        {
            cout<<fib[n]<<endl;
            continue;
        }
        printf("%I64d\n",solve(n));

    }
    return 0;
}

HDU3177 

/************************
G++交
************************/
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#define  mod 10000
using namespace std;


__int64 fib[50];

struct matrix
{
    __int64 a[2][2];

    void clear()
    {
        memset(a,0,sizeof(a));
    }

    matrix operator +(const matrix &b)const
    {
        matrix c;
        c.clear();
        for(int i=0; i<2; i++)
        {
            for(int j=0; j<2; j++)
            {
                c.a[i][j]=(a[i][j]+b.a[i][j])%mod;
            }
        }
        return c;
    }

    matrix operator *(const matrix &b)const
    {
        matrix c;
        c.clear();
        for(int i=0; i<2; i++)
        {
            for(int j=0; j<2; j++)
            {
                for(int k=0; k<2; k++)
                {
                    c.a[i][j]+=a[i][k]*b.a[k][j];
                }
                c.a[i][j]%=mod;
            }
        }
        return c;
    }
};

matrix power(matrix a,int b)
{
    matrix ans;
    for(int i=0; i<2; i++)
    {
        for(int j=0; j<2; j++)
        {
            ans.a[i][j]=(i==j);
        }
    }

    while(b)
    {
        if(b&1)
            ans=ans*a;
        a=a*a;
        b>>=1;
    }
    return ans;
}

__int64 solve(__int64 n)
{
    double ans = -0.5 * log10(5.0) + n * log10((sqrt(5.0) + 1) / 2);
    __int64 d = (__int64)ans;
    ans -= d;
    ans = pow(10.0, ans);
    while(ans < 1000)
        ans *= 10;
    return (__int64)ans;
}

int main()
{
   // freopen("C:\\Users\\Administrator\\Desktop\\in.txt" , "r" , stdin);
    int n;
    fib[0]=0;
    fib[1]=1;
    for(int i=2; i<40; i++)
    {
        fib[i]=fib[i-1]+fib[i-2];
    }
    while(~scanf("%I64d",&n))
    {
        if(n<40)
        {
            cout<<fib[n]<<endl;
            continue;
        }
        else
        {
            printf("%I64d...",solve(n));
            matrix a,b;
            a.a[0][0]=a.a[0][1]=a.a[1][0]=1;
            a.a[1][1]=0;
            b=power(a,n);
            printf("%04d\n",b.a[0][1]%mod);
        }
    }
    return 0;
}

 

这是关于求位数的公式，在具体实现上面可以参考这个博客它里面讲解的比较好：http://hi.baidu.com/aekdycoin/item/a4407c37850e5b9db80c03a6

HDU1588

这个题目比较有意思，对于g(i)=k*i+b,，那么在【0，n-1】之内求f(g(i)),有前面这些题目的铺垫可知：f(i)=A^i,那么就有sum=f(g(0))+……f(g(n-1))

展开就有sum=f(b)+f(k+b)+……f((n-1)*k+b)

                        =A^b+A^(k+b)……A^((n-1)*k+b)

                        =A^b(A^0+A^k+A^2k+……A^((n-1)*k))  在这儿就是把A^b提取公因数，记做AA

                        =A^b((A^0+(A^k)+(A^k)^2+……(A^k)^n-1)    把A^k作为一个公因式再提出来，记做K

                        =AA*(A^0+K^1+K^2+……K^（n-1）)

这样就比较容易做出来了  只是要注意还有一个A^0要加上去

#include<iostream>
#include<iomanip>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<climits>
using namespace std;

__int64 mod;

struct matrix
{
    __int64 a[2][2];

    void init()
    {
        a[0][0]=a[1][1]=1;
        a[0][1]=a[1][0]=0;
    }

    void clear()
    {
        memset(a,0,sizeof(a));
    }

    matrix operator +(const matrix &b)const
    {
        matrix c;
        c.clear();
        for(int i=0; i<2; i++)
        {
            for(int j=0; j<2; j++)
            {
                c.a[i][j]=(a[i][j]+b.a[i][j])%mod;
            }
        }
        return c;
    }

    matrix operator *(const matrix &b)const
    {
        matrix c;
        c.clear();
        for(int i=0; i<2; i++)
        {
            for(int j=0; j<2; j++)
            {
                for(int k=0; k<2; k++)
                {
                    c.a[i][j]+=(a[i][k]*b.a[k][j]);
                }
                c.a[i][j]=c.a[i][j]%mod;
            }
        }
        return c;
    }
};

matrix pow(matrix a,int b)
{
    matrix ans;
    ans.init();
    while(b)
    {
        if(b&1)
        {
            ans=ans*a;
        }
        a=a*a;
        b>>=1;
    }
    return ans;
}

matrix pow_sum(matrix a,int k)
{
    matrix ans,temp;
    if(k==1)return a;
    temp=pow_sum(a,k>>1);
    ans=temp+temp*pow(a,k>>1);
    if(k&1)
    {
        ans=ans+pow(a,k);
    }
    return ans;
}

__int64 k,b,n;
int main()
{
    //freopen("C:\\Users\\Administrator\\Desktop\\in.txt" , "r" , stdin);
   // freopen("C:\\Users\\Administrator\\Desktop\\out.txt" , "w" , stdout);
    matrix a,e,ab,ak,sum,ans;
    while(~scanf("%I64d%I64d%I64d%I64d",&k,&b,&n,&mod))
    {
        a.a[0][0]=a.a[0][1]=a.a[1][0]=1;
        a.a[1][1]=0;
        e.init();
        ab=pow(a,b);
        ak=pow(a,k);
        sum=pow_sum(ak,n-1)+e;
        ans=ab*sum;
        printf("%d\n",ans.a[0][1]%mod);
    }
    return 0;
}




AC_王道
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
矩阵常用操作
qq_42077227的博客
08-17 237
矩阵的切割，拼接，向量与矩阵的转换函数 import Numpy as np np.sqrt（A）对a开根号 a=np.floor（10*np.random.random（2,3））取随机值*10 np.floor对浮点型向下取整， a.ravel（）把一个2行三列的矩阵变为一个向量 a.shape=（3,2）可以把一个向量变为一个3行两列的矩阵 a.T行列...
矩阵经典操作（1）
AC_Dream
08-19 694
关于矩阵的经典操作1，那就是坐标的变换 通过二维空间或者三维空间，给定n个点，m 个操作，构造O(m+n)的算法输出m个操作后各点的位置，操作有平移、缩放、翻转和旋转 参考：十个利用矩阵乘法解决的经典题目 在三维空间中就是扩张一下就可以了，只是在三维空间的旋转，如果给定的是角度，那么就要注意公式如下： 因此要注意一下，这是针对角度和坐标点 HDU3320 题目连接：ht
矩阵经典操作（2）
AC_Dream
08-19 742
关于矩阵经典操作（2）只要是关于矩阵求幂或者求前K次方的和 这些题目一般题目会给定矩阵，这属于模板题，比较简单 关于整数快速幂，在数论里有一个比较快速的算法，矩阵的快速幂和这个差不多，有异曲同工的意思，都是二分的思想 整数快速幂： long long power(long long a,long long b) { long long ans=1; while(b)
基本矩阵操作
一个搬运知识的笨小孩
03-04 1907
1. 基本矩阵操作 1. 1 矩阵和数组的区别和联系 矩阵和数组的区别 矩阵是数学上的概念 数组是计算机程序设计领域的概念 矩阵运算有明确而严格的数学规则 数组运算作为MATLAB软件定义的规则，其目的为了使数据管理方便，操作简单 矩阵和数组的联系 在MATLAB中，矩阵是以数组的形式存在 因此，一维数组相当于向量，二维数组相当于矩阵 所以，矩阵是数组的子集 1.2 矩阵的构造 矩阵的构造方式有2种： 第一种： 对变量直接进行赋值 第二种： MATLAB中提供构建特殊矩阵的指令 1.2.0 建立简单矩阵
矩阵经典操作（3）
AC_Dream
08-24 618
矩阵解决置换的问题 hdu2371 /********************* http://acm.hdu.edu.cn/showproblem.php?pid=2371 题意：给定一个n，k，其中n表示字符串大小，同时也是置换的序列的大小 k表示置换的次数，再输入一个字符串，求一个初始串，使这个串通过k次 置换后变成我们输入的串 思路：以前是给定初始串求结果，这次是给定结果求初始串，
MATLAB矩阵基础操作，提供一些基础操作示例
08-24
MATLAB矩阵基础操作，提供一些基础操作示例 MATLAB矩阵基础操作 1 矩阵的创建与合并 3 矩阵的寻访与赋值 3 常用数组运算函数 4 查询矩阵信息 4 矩阵的重构 4 矩阵的创建与合并 通过初值，步长，终值的方式 A=2:2:20 ...
Matlab矩阵数组操作大全
03-18
4.矩阵和数组处理：求矩阵元素的平方，求矩阵元素的绝对值，求矩阵元素的对数，求矩阵元素指数，对矩阵元素进行四舍五入，求矩阵中的最大值与最小值，对矩阵中的每一列进行求和，对矩阵中的每一行求和，对矩阵中的每...
Python中的Numpy矩阵操作
12-25
NumPy 是一个非常优秀的提供矩阵操作的包。NumPy的主要目标，就是提供多维数组，从而实现矩阵操作。 NumPy’s main object is the homogeneous multidimensional array. It is a table of elements (usually ...
MATLAB的符号矩阵操作
最新发布
02-19
MATLAB的符号矩阵操作
matlab matlab 数组与矩阵操作
09-24
"MATLAB 数组与矩阵操作" MATLAB 是一款为科学家和工程师量身打造的强大软件，是进行计算、模拟、数据分析和可视化等任务的理想工具。它拥有简洁直观的界面和强大的功能，能够轻松处理复杂数学运算和算法开发。...
线性代数2.2矩阵运算
随缘写随缘更新
09-28 1万+
1.6矩阵运算 矩阵加法 矩阵元素对应相加，显然只有同型矩阵才能相加 矩阵减法 矩阵元素对应相减，显然只有同型矩阵才能相减 加法减法满足的运算率 矩阵数乘 矩阵所有元素均有公因子，所有公因子朝外提一次 行列式提公因子：一行提一次 所有元素均有外提n次 矩阵乘法 与行列式乘法规则一致，行的每一个元素乘以列每一个元素，先相乘再相加 注:矩阵相乘前提 第一个矩阵的列数 == 第二个矩阵的行数 结果矩阵形状：结果矩阵的行数 == 第一行的行数 ， 结果矩阵的列数 = 第二个列数 非常牛b的宋氏七字口诀 中间
《算法竞赛入门经典》---S5----STL
DorisBao1021的博客
10-18 279
*UVA  1592---map 大概就是要找出两组位置有相同的string string查找对比时太慢 所以 map一下  就是不同的二行  对应二列字符串相同 【解】 数据： How to compete in ACM ICPC,Peter,peter@neerc.ifmo.ru How to win ACM ICPC,Michael,michael@neerc.ifmo.ru N...
数组和矩阵操作
拱头的专栏
10-26 650
创建数组和矩阵： 维度向量由dim()指定，例如，z是一个由1500个元素组成的向量。下面的赋值语句 > dim(z) #的数组进行处理。 c(3,5,100) 就是他的维度向量。 #还可以用到像matrix()和array()这样的函数来赋值。比如 > array(1:20, dim=c(4,5)) > matrix(1:24, 3,4) scale(x,center=T
Python基础学习：cmath模块
zhtysw的博客
04-12 6094
cmath——复数域数学函数模块       该模块属于内置模块，随时可以调用。它提供了数学函数在复数域上扩展的运算函数，math模块内的函数属于其子集，该模块是为了某些需要在复数域上进行的操作站门设计的。该模块的函数允许复数、整数、浮点数等数据类型的输入。如无特殊说明，所有函数的返回值都应当为实部、虚部皆为浮点数的复数。1 极坐标与直角坐标的相互转换函数       在Python中，复数使用矩...
矩阵操作
一个搬运知识的笨小孩
03-07 1170
目录1. 矩阵操作1.1 创建矩阵1.1.0 Hilbert Matrix1.1.1 Toeplitz Matrix 1. 矩阵操作 1.1 创建矩阵 1.1.0 Hilbert Matrix 希尔伯特矩阵，也称 H 阵，其元素为　Hij=1i+j−1H_{ij}=\frac{1}{i+j-1}Hij​=i+j−11​由于它是一个条件数差的矩阵，所以将它用来作为试验矩阵 hilb(n)：用于生成一个n×n的希尔伯特矩阵 invhilb(n)：用于生成一个n×n的希尔伯特矩阵的逆矩阵整数矩阵 希尔伯特矩阵
C#使用Math.Net库进行矩阵运算
热门推荐
灰太狼的小秘密
04-01 2万+
一、基础知识 1、Math.net是什么 Math.net计算库是专为.NET开发的开源科学计算库。包含了大部分矩阵运算、线性运算等功能。效率高，且可以在C#中直接使用。简单的矩阵运算，其效率可以达到C#代码的10倍以上。 开源地址：http://mathnetnumerics.codeplex.com Math.NETNumerics是核心功能是数值计算。主要是提供日常科学工程计...
scipy矩阵操作
tinymd的博客
11-14 1210
转载scipy矩阵操作
matlab矩阵的表示和简单操作
weixin_34071713的博客
12-11 9380
matlab矩阵的表示和简单操作 一、矩阵的表示在MATLAB中创建矩阵有以下规则：a、矩阵元素必须在”[ ]”内；b、矩阵的同行元素之间用空格（或”,”）隔开；c、矩阵的行与行之间用”;”（或回车符）隔开；d、矩阵的元素可以是数值、变量、表达式或函数；e、矩阵的尺寸不必预先定义。 二，矩阵的创建：1、直接输入法最简单的建立矩阵的方法是从键盘...
matlab矩阵操作基础PPT课件.ppt
11-24
"MATLAB矩阵操作基础PPT课件" MATLAB是一种强大的数学计算软件，尤其在处理矩阵和数组运算方面表现出色。它被广泛应用于工程、科学计算和数学领域，作为一个编程语言和可视化工具，MATLAB以其简洁的人机交互界面和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值