矩阵专题训练1

最新推荐文章于 2022-11-18 20:59:55 发布
最新推荐文章于 2022-11-18 20:59:55 发布
阅读量772 收藏
点赞数
分类专栏： 数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011481752/article/details/21749775
版权

HDU 1757

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

题意很清楚不同的X对应不同的FX，而且当X>=10时，有一个递推公式，因为N比较大，所以简单的暴力去写肯定不可能，所以要构造矩阵用快速幂解决。。。

思路：前10个FX简单保存下值，然后当X>=10时构造10*10的进行快速幂的矩阵 和10*1的初始矩阵。

大致可以写成/*****************************************
|0 1 0 0 0 0 0 0 0 0 |  |f(x-10)|   |f(x-9)|
|0 0 1 0 0 0 0 0 0 0 |  |f(x-9) |   |f(x-8)|
|0 0 0 1 0 0 0 0 0 0 |  |f(x-8) |   |f(x-7)|
|0 0 0 0 1 0 0 0 0 0 |  |f(x-7) |   |f(x-6)|
|0 0 0 0 0 1 0 0 0 0 |* |f(x-6) |=  |f(x-5)|
|0 0 0 0 0 0 1 0 0 0 |  |f(x-5) |   |f(x-4)|
|0 0 0 0 0 0 0 1 0 0 |  |f(x-4) |   |f(x-3)|
|0 0 0 0 0 0 0 0 1 0 |  |f(x-3) |   |f(x-2)|
|0 0 0 0 0 0 0 0 0 1 |  |f(x-2) |   |f(x-1)|
|a9 a8 a7 a6 a5... a1|  |f(x-1) |   |f(x)  |
******************************************/然后就O了，当时代码写的较矬 我自己都看不懂了。。。

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

int a[10][10];
int ans[10];
int k,m;
int f[20];
int b[10];
void fun()
{
    memset(f,0,sizeof(f));
    for(int i=0;i<=9;i++)
    {
        f[i]=i;
        f[i]%=m;
    }
    for(int i=10;i<20;i++)
    {
        for(int j=0;j<=9;j++)
        {
            f[i]+=(b[j]*f[i-j-1])%m;
            f[i]%=m;
        }
    }
}
void cheng1()
{
    int temp[10];
    memset(temp,0,sizeof(temp));
    for(int i=0;i<10;i++)
    {
        for(int j=0;j<10;j++)
        {
            temp[i]+=(ans[j]*a[j][i])%m;
            temp[i]%=m;
        }
    }
    for(int i=0;i<10;i++)
    {
        ans[i]=temp[i];
    }
}

void cheng2()
{
    int temp1[10][10];
    memset(temp1,0,sizeof(temp1));
    for(int i=0;i<10;i++)
    {
        for(int j=0;j<10;j++)
        {
            for(int k=0;k<10;k++)
            {
                temp1[i][j]+=(a[i][k]*a[k][j])%m;
                temp1[i][j]%=m;
            }
        }
    }
    for(int i=0;i<10;i++)
    {
        for(int j=0;j<10;j++)
        {
            a[i][j]=temp1[i][j];
        }
    }
}
int main()
{
    while(cin>>k>>m)
    {
        memset(a,0,sizeof(a));
        for(int i=0;i<10;i++)
        {
            cin>>b[i];
            a[i][0]=b[i];
        }
        for(int i=1;i<10;i++)
        {
            a[i-1][i]=1;
        }
        fun();
        if(k<=19)
        {
            cout<<f[k]<<endl;
        }
        else
        {  k=k-19;
           for(int i=0;i<10;i++)
           {
               ans[i]=f[19-i];
           }
           while(k)
           {
               if(k%2==0)
               {
                   cheng2();
                   k/=2;
               }
               else
               {
                   cheng1();
                   k--;
               }
           }
         cout<<ans[0]<<endl;
        }

    }
    return 0;
}
POJ 3233

求 S = A + A2 + A3 + … + Ak.

思路：对矩阵进行二分求和，若K为奇数，多出来的那个数直接快速幂，剩余的进行二分求和，然后二分进行递归按照是奇数单独拿一个去快速幂的思路可以敲出。

http://poj.org/problem?id=3233

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

struct juzhen{

int m[30][30];


};
int n,k,mod;

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

juzhen add(juzhen a,juzhen b)
{
    juzhen c;
    memset(c.m,0,sizeof(c.m));

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

juzhen pow(juzhen a,int p)
{
    juzhen c;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(i==j)
            {
                c.m[i][j]=1;
            }
            else
            {
                c.m[i][j]=0;
            }
        }
    }
    while(p)
    {
        if(p%2==0)
        {
            a=mut(a,a);
            p/=2;
        }
        else
        {
            c=mut(c,a);
            p--;
        }
    }
    return c;
}

juzhen erfen(juzhen a,int p)
{
    if(p==1)
        return a;
    if(p==2)
        return add(a,mut(a,a));
    if(p%2==1)
    {
        return add(erfen(a,p-1),pow(a,p));
    }
    if(p%2==0)
    {
        juzhen c;
        c=erfen(a,p/2);//这里先进行二分省的进入递归时每次再进行这步操作可以提高效率。。一开始没优化狂T。
        return add(c,mut(pow(a,p/2),c));
    }


}

int main()
{
    scanf("%d%d%d",&n,&k,&mod);

        juzhen a;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
               scanf("%d",&a.m[i][j]);
            }
        }
        a=erfen(a,k);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                printf("%d ",a.m[i][j]);
            }
            printf("\n");
        }





    return 0;
}

HDU 1588

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

也是矩阵二分求和，而且F是斐波那契矩阵只不过注意F（G（n））=F(K*n+b)=a^b(a^0+a^k+a^2k+a^3k+...a^(n-1)*k)

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

struct juzhen{

long long  m[2][2];

};

long long  k,b,n,M;

juzhen mut(juzhen a,juzhen b)
{
    juzhen c;
    for(long long  i=0;i<2;i++)
    {
        for(long long  j=0;j<2;j++)
        {
            c.m[i][j]=0;
            for(long long  k=0;k<2;k++)
            {
                c.m[i][j]+=(a.m[i][k]*b.m[k][j])%M;
                c.m[i][j]%=M;
            }
        }
    }
    return c;
}

juzhen add(juzhen a,juzhen b)
{

    juzhen c;
    memset(c.m,0,sizeof(c.m));
    for(long long  i=0;i<2;i++)
    {
        for(long long  j=0;j<2;j++)
        {
            c.m[i][j]+=(a.m[i][j]+b.m[i][j])%M;
            c.m[i][j]%=M;
        }
    }
    return c;
}


juzhen pow(juzhen a,long long  p)
{
    juzhen b;
    b.m[0][0]=b.m[1][1]=1;
    b.m[0][1]=b.m[1][0]=0;

    while(p)
    {
        if(p%2==0)
        {
            a=mut(a,a);
            p/=2;
        }
        else
        {
            b=mut(b,a);
            p--;
        }
    }
    return b;
}


juzhen erfen(juzhen a,long long  p)
{
    if(p==1)
        return a;
    if(p==2)
        return add(a,mut(a,a));
    if(p%2==1)
    {
        return add(erfen(a,p-1),pow(a,p));
    }
    if(p%2==0)
    {
        juzhen c;
        c=erfen(a,p/2);
        return add(c,mut(pow(a,p/2),c));

    }
}

int  main()
{
    while(cin>>k>>b>>n>>M)
    {
        juzhen a;
        a.m[0][0]=a.m[0][1]=a.m[1][0]=1;
        a.m[1][1]=0;
        juzhen aa;
        aa=pow(a,b);
        juzhen bb;
        bb=pow(a,k);
        juzhen cc;
        cc=erfen(bb,n-1);
        juzhen dd;
        dd=mut(aa,cc);
        juzhen ans;
        ans=add(aa,dd);
        cout<<ans.m[0][1]<<endl;

    }


    return 0;

}

HDU 3306

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

Now we define another kind of Fibonacci : A(0) = 1 , A(1) = 1 , A(N) = X * A(N - 1) + Y * A(N - 2) (N >= 2).And we want to Calculate S(N) , S(N) = A(0)2 +A(1)2+……+A(n)2.

首先把AN平方有A(N)^2=X^2*A(N-1)^2+Y^2*A(N-2)^2+2*X*Y*A(N-1)*A(N-2) ，根据这个式子可以构造：

|1 x*x y*y 2*x*y|   |   SUMN      | |   SUMN+1      |
|0 x*x y*y 2*x*y|   |   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) |

特别注意A（N）*A（N-1）=（X*A(N-1)+Y*A(N-2)）*A(N-1)=X*A(N-1)^2+Y*A(N-1)*(N-2)故最后一阶构造成0 X 0 Y的形式

剩下的。。就是注意取余的问题了。。

当然如果下次要求SUM类的矩阵记得在原定义的矩阵上多加一阶用来存放SUM的值然后就O了。

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


int n,x,y;
const int mod=10007;

struct juzhen {

int m[4][4];

};


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

juzhen pow(juzhen a,int p)
{
    juzhen b;
    memset(b.m,0,sizeof(b.m));
    for(int i=0;i<4;i++)
    {
        b.m[i][i]=1;
    }

    while(p)
    {
        if(p%2==0)
        {
            a=mut(a,a);
            p/=2;
        }
        else
        {
            b=mut(b,a);
            p--;
        }
    }
    return b;
}


int main()
{
    while(cin>>n>>x>>y)
    {
        juzhen a;
        x%=mod;
        y%=mod;
        a.m[0][0]=a.m[2][1]=1;
        a.m[1][0]=a.m[2][0]=a.m[3][0]=a.m[2][2]=a.m[2][3]=a.m[3][2]=0;
        a.m[0][1]=a.m[1][1]=(x*x)%mod;
        a.m[0][2]=a.m[1][2]=(y*y)%mod;
        a.m[0][3]=a.m[1][3]=(2*x*y)%mod;
        a.m[3][1]=x%mod;
        a.m[3][3]=y%mod;
        juzhen ans;
        ans=pow(a,n-1);

        int sum;
        sum=(2*ans.m[0][0]+ans.m[0][1]+ans.m[0][2]+ans.m[0][3])%mod;
        cout<<sum<<endl;


    }

return 0;

}

今天先写简单写下四题。。大概刷了12题，然后明天有时间更新2和3，智商比较低代码比较挫还望勿见怪，实力有限。。还得继续努力。。。

.


何时成为GT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
矩阵分析与 应用习题解答
02-27
矩阵分析与 应用习题解答矩阵分析与 应用习题解答矩阵分析与 应用习题解答
十个利用矩阵乘法解决的经典题目
matrix67的专栏
08-04 2470
    好像目前还没有这方面题目的总结。这几天连续看到四个问这类题目的人，今天在这里简单写一下。这里我们不介绍其它有关矩阵的知识，只介绍矩阵乘法和相关性质。    不要以为数学中的矩阵也是黑色屏幕上不断变化的绿色字符。在数学中，一个矩阵说穿了就是一个二维数组。一个n行m列的矩阵可以乘以一个m行p列的矩阵，得到的结果是一个n行p列的矩阵，其中的第i行第j列位置上的数等于前一个矩阵第i行
方阵函数的计算
weixin_44979900的博客
03-06 2928
方阵函数的计算一般有两种方式：Jordan标准型法和最小多项式法。 Jordan标准型法 假设存在矩阵A,有A=PJP-1.我们已知存在f(A)=Pf(J) P-1.也就是若对矩阵A函数计算，可以通过先对它的相似Jordan标准型J进行相同函数计算，之后左乘变换矩阵P,右乘变换矩阵P-1得到需要的结果。 这是因为对于Jordan标准型而言，函数计算存在以下方便的计算方法： 也就是对Jordan标准型矩阵的计算可以转换为对对角元λ的代数计算，矩阵计算变代数计算，显然简化了许多。之后再左乘变换矩阵P,
二维数组典型应用题--矩阵最大平台
最新发布
MGherobrine的博客
11-18 529
定义类型：类型名 数组名[ 行表达式 ][ 列表达式]；行与列用常量表达式。 例如：a[100][100]这就开了一个一百乘一百的方阵数组(当然二维数组也可以开成长方形的) 注：一个二维数组，在本质上是有多个一维数组构成。（每一个一维数的大小必须相同） 例如：定义 int a[ 3 ][ 4 ] 的二维数组，它是由 3 个一维数组组成，每个一维数组的大小是 4 个整型元素。可以只对部分元素赋值，未赋值的元素自动取 0 值。
矩阵分析L6矩阵函数
lee2813的博客
12-14 4432
一、范数 1.范数与内积 内积：对两个空间进行内积运算可以得到一个实数集 范数：对一个空间可以直接进行向量“大小”的衡量，得到实数集 2.向量范数 正定性：范数为0，则每个向量必为0 3.例题（向量范数判断） 4.p级范数 注意，范数|Y|若是一个平面直角坐标系，横轴为实数，纵轴为虚数。值为平面坐标系中线段长度。 x的1-范数为：1+|2+i|+|i|+1= 根号（5） + 3 x的2-范数为：根号（1+5+1+1）= 根号（8） x的无穷范数为：max{1,根号（5），1,1}=根号（5
2020高考数学 专题练习 三十一 行列式与矩阵 理.doc
10-12
【行列式与矩阵】是高等数学中的核心概念，主要出现在线性代数的学习中。行列式是一个数值，由矩阵的...通过此类专题练习，学生可以提升矩阵运算能力，理解矩阵与几何变换的关系，以及学会如何运用行列式性质解决问题。
dp专题讲义1
08-03
动态规划是一种重要的算法思想，广泛应用于解决最优化问题。它基于分治策略，将一个大问题分解成多个小问题，并利用这些小问题的解来构建...通过不断练习和深入研究，我们可以更好地运用动态规划来解决复杂的计算问题。
高考专题训练三十一行列式与矩阵(选修4-2).pdf
10-01
高考专题训练三十一行列式与矩阵(选修4-2).pdf
大一暑假专题练习ac代码
08-19
【大一暑假专题练习ac代码】是针对计算机科学与技术专业学生的一次专项训练，主要集中在算法的学习和实践上。AC代码通常指的是在算法竞赛（如ACM/ICPC或LeetCode等）中，能够正确解决特定问题的程序代码，这里的“AC...
附加题专题练习6学生.doc
11-18
【附加题专题练习6学生.doc】是一份针对高中学生的数学练习，主要涵盖了矩阵变换、极坐标系中的几何问题、空间几何以及组合计数四个知识点。 1. **矩阵变换与向量旋转** 点M(3, -1)绕原点逆时针旋转90°后，坐标...
【C++练习题】求任意行列的两个矩阵的乘积（普通函数实现+类实现）
水亦心的博客
11-19 5523
一、题目 学弟问了一道题，想想好久没有写C++的题了，想着练练手，也把这道题分享给大家。 我们知道用matlab实现这个代码是很容易的，毕竟玩矩阵，matlab是专业的，C++就不一样了，考虑的问题有好多，实现方法也有很多，我就把自己写的分享给大家。 我们用一个两行两列的矩阵A和两行三列的矩阵B做测试： 二、普通函数实现 1、代码 #include&lt;iostream&...
矩阵论: 第四章 矩阵函数及其应用
fengxuewei123的博客
01-03 1440
向量范数 和 矩阵范数 向量和矩阵的极限
矩阵分析与应用
热门推荐
会思考的蜗牛
05-31 1万+
第三讲依然是数学，因为数学是解决一切问题的基础。一个问深入到最后都是数理知识的支撑。所谓基础决定上层建筑，比如参加ACM比赛，高手之间的比赛已经不是编程技巧了，更多的是数学知识的比拼。若想走得远，数学基础一定要打好。嗯，好遗憾之前学数学多是为了考试，学完就忘，现在要好好再复习一下。 程博士用两个小时概讲了《线性代数》《矩阵论》两本书的内容，结合其他的相关资料，总结一下。
十个利用矩阵乘法解决的经典题目(个人小结)
Bright-XL
08-28 3615
看了Matrix67大神的博客做的一个小结。也让我对矩阵有了一个全新的认识。 传送阵 经典题目1 给定n个点，m个操作，构造O(m+n)的算法输出m个操作后各点的位置。操作有平移、缩放、翻转和旋转     这里的操作是对所有点同时进行的。其中翻转是以坐标轴为对称轴进行翻转（两种情况），旋转则以原点为中心。如果对每个点分别进行模拟，那么m个操作总共耗时O(mn)。利用矩阵乘法可以在O(m)
【市赛真题】温馨的家（矩阵运用题）
qq_34860220的博客
03-21 1188
【问题描述】 企鹅皮皮从小就是一个淘气的孩子。现在,他已经长大了,需要自己建一个新家了。你知道企鹅的家里用小石块在地面上铺出来的吧?为了让自己的家看起来更漂亮,皮皮找了很多钟不同颜色的石块,并把它们铺成一圈一圈的:先找某种颜色的一颗放中心,在它周围铺上一圈第二种颜色的,再在周围铺上一圈第三种颜色的。。。。。。 当然这是一个漂亮的家。 你能用你的知识,让计算机画出皮皮的家吗? 【输入】 输入一...
CCNU第五周赛前练习：将一个数分解成质因子相乘的形式
u011481752的专栏
08-16 1758
K - Number theory-2 Time Limit:1000MS    Memory Limit:32768KB    64bit IO Format:%I64d & %I64u SubmitStatus Description Eddy's interest is very extensive, recently he is interested in pri
Codeforces Beta Round #17 D题 福大核武 景润后人！！！
u011481752的专栏
07-30 1699
D. Notepad time limit per test 2 seconds memory limit per test 64 megabytes input standard input output standard output Nick is attracted by everything unconventional. He doesn't
有限域的某一章节的某一小部分的简单证明
u011481752的专栏
05-09 1563
有限域基础13.2部分笔记定义Zps[x]\mathbb{Z}_{p ^ s}[x]上的两个多项式f1f_{1}和f2f_{2},如果存在两个Zps[x]\mathbb{Z}_{p ^ s}[x]上的多项式λ1\lambda_{1}和λ2\lambda_{2},满足λ1f1+λ2f2=1\lambda_{1}f_{1} + \lambda_{2}f_{2} = 1,也即满足Zps[x]f1+Zps[
HDU4565 2013长沙赛区邀请赛A题。。。
u011481752的专栏
05-19 1269
So Easy! Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1989    Accepted Submission(s): 613 Problem Description 　　A sequence Sn is def
矩阵运算与AI架构：深度学习中的GPU与TPU优化
在本篇人工智能专题文章中，我们将深入探讨矩阵运算在计算机体系结构中的应用，特别是在人工智能领域。矩阵运算作为核心算法基础，对于深度学习模型如卷积神经网络（CNN）和全连接层的计算至关重要。我们首先通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值