【城会玩】hdu 4920 Matrix multiplication【矩阵相乘优化】

最新推荐文章于 2024-11-07 16:28:09 发布

mengxiang000000

最新推荐文章于 2024-11-07 16:28:09 发布

阅读量464

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.csdn.net/mengxiang000000/article/details/51932183

城会玩专栏收录该内容

12 篇文章

订阅专栏

本文介绍了一种矩阵乘法的优化方法，通过调整循环顺序并在适当的位置加入continue语句来减少不必要的计算，尤其是在处理大量0元素的情况下效果显著。提供了一个具体的C++实现案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Matrix multiplication

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 4220 Accepted Submission(s): 1692

Problem Description

Given two matrices A and B of size n×n, find the product of them.

bobo hates big integers. So you are only asked to find the result modulo 3.

Input

The input consists of several tests. For each tests:

The first line contains n (1≤n≤800). Each of the following n lines contain n integers -- the description of the matrix A. The j-th integer in the i-th line equals A _ij. The next n lines describe the matrix B in similar format (0≤A _ij,B _ij≤10 ⁹).

Output

For each tests:

Print n lines. Each of them contain n integers -- the matrix A×B in similar format.

Sample Input

1
0
1
2
0 1
2 3
4 5
6 7

Sample Output

0
0 1
2 1

Author

Xiaoxu Guo (ftiasch)

Source

2014 Multi-University Training Contest 5

Recommend

We have carefully selected several similar problems for you: 5717 5716 5715 5714 5713

题目大意：输入一个n，表示两个矩阵的大小，然后接下来两个n*n的矩阵输入，要求输出一个矩阵，表示求得两个矩阵相乘的矩阵。

思路;

1、我们来看直接根据矩阵乘法规则写的代码：

<span style="white-space:pre">	</span>for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                for(int k=0;k<n;k++)
                {
                    c[i][j]+=a[i][k]*b[k][j];
                    c[i][j]%=mod;
                }
            }
        }

如果我们想在这里进行一些优化的话，只能变成这样：

        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                for(int k=0;k<n;k++)
                {
                    if(a[i][k]==0||b[k][j]==0)continue;
                    c[i][j]+=a[i][k]*b[k][j];
                    c[i][j]%=mod;
                }
            }
        }

显然优化与否没差。

那么思考：如果我们能在第一层或者第二层for那里加一个continue，那么显然能够优化一层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];
                    c[i][j]%=3;
                }
            }
        }

其实就是一行一行的往上加，那么这个时候我们在第二层for那里能够加这样一个优化：

        for(int i=0;i<n;i++)
        {
            for(int k=0;k<n;k++)
            {
                if(a[i][k]==0)continue;
                for(int j=0;j<n;j++)
                {
                    c[i][j]=c[i][j]+a[i][k]*b[k][j];
                    c[i][j]%=3;
                }
            }
        }

如果0存在比较多的话，优化也就比较多。

那么根据这种求矩阵乘法的方法来做这个题，相对就能够优化很多操作了：

#include<stdio.h>
#include<string.h>
using namespace std;
#define mod 3
int a[802][820];
int b[802][820];
int c[802][820];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                scanf("%d",&a[i][j]);
                a[i][j]%=3;
            }
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                scanf("%d",&b[i][j]);
                b[i][j]%=3;
                c[i][j]=0;
            }
        }
        for(int i=0;i<n;i++)
        {
            for(int k=0;k<n;k++)
            {
                if(a[i][k]==0)continue;
                for(int j=0;j<n;j++)
                {
                    c[i][j]=c[i][j]+a[i][k]*b[k][j];
                    c[i][j]%=3;
                }
            }
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n-1;j++)
            {
                printf("%d ",c[i][j]);
            }
            printf("%d\n",c[i][n-1]);
        }
    }
}