HDU 4920 Matrix multiplication

题意：很简单，给出两个矩阵，求出两个矩阵的乘积。但是矩阵最大是800*800

思路：n^3的暴力可过，但是要有优美的姿势。就是把优化进行到底。

第一版：很自然的写了一个矩阵的结构体，把大小开到800*800。结果就RE了，原因是STACK_OVER_FLOW，栈溢出！！

代码如下：

#include <cstdio>
#include <cstring>
#include <vector>
#include <cctype>

using namespace std;

template<class T>
inline bool read(T &n)
{
    T signal = 1,x = 0;
    char ch = getchar();
    while((ch <'0' || ch >'9') && ch != EOF && ch != '-')
        ch = getchar();
    if(ch == EOF)  return false;
    if(ch == '-')  ch = getchar(), signal = -1;
    while(ch <='9' && ch >='0'){
        x *= 10;
        x += ch -'0';
        ch = getchar();
    }
    n = x * signal;
    return true;
}
template<class T>
inline void write(T n)
{
    if(n < 0)
        putchar('-'), n = -n;
    int len = 0, num[20];
    while(n)
        num[len++] = n % 10, n /= 10;
    if(len == 0)
        num[len++] = 0;
    while(len--)
        putchar(num[len]+'0');
}


const int  MOD = 3;
int n;

struct Matrix{
    static const int MAXN = 800;
    int column,row;
    int a[MAXN][MAXN];
    Matrix(int m=0, int n=0):column(m),row(n)
    {memset(a,0,sizeof(a));}

    Matrix operator * (const Matrix & B) const{
        Matrix C(row, B.column);
        for(int k = 0; k < column; ++k)
            for(int i = 0 ; i < C.row; ++i)
                for(int j = 0; j <C.column;++j)
                C.a[i][j] = (C.a[i][j] + a[i][k] * B.a[k][j] ) % MOD;
        return C;
    }
};

Matrix A,B;

int main(void)
{
    freopen("input.txt","r",stdin);
    while(read(n)){
        A.column = B.column = A.row = B.row = n;
       // printf("%d %d %d %d\n",A.column , B.column , A.row , B.row);
        for(int i = 0 ; i < A.row; ++i)
            for(int j = 0 ; j < A.column; ++j)
                read(A.a[i][j]),A.a[i][j] %= MOD;
        for(int i = 0 ; i < B .row; ++i)
            for(int j = 0; j < B.column; ++j)
                read(B.a[i][j]),B.a[i][j] %= MOD;
        A = A * B;
        for(int i = 0 ; i < A.row; ++i)
            for(int j = 0; j < A.column; ++j)
                write(A.a[i][j]),putchar(j == A.column - 1?'\n':' ');
    }
    return 0;
}

第二版本：看来要手动扩栈了，C++走起。终于不是RE了，变成了TLE

#include <cstdio>
#include <cstring>
#include <vector>
#include <cctype>
#pragma comment(linker, "/STACK:10240000000,10240000000")//手动扩栈命令，只有C++可用

using namespace std;

template<class T>
inline bool read(T &n)
{
	T signal = 1, x = 0;
	char ch = getchar();
	while ((ch <'0' || ch >'9') && ch != EOF && ch != '-')
		ch = getchar();
	if (ch == EOF)  return false;
	if (ch == '-')  ch = getchar(), signal = -1;
	while (ch <= '9' && ch >= '0'){
		x *= 10;
		x += ch - '0';
		ch = getchar();
	}
	n = x * signal;
	return true;
}
template<class T>
inline void write(T n)
{
	if (n < 0)
		putchar('-'), n = -n;
	int len = 0, num[20];
	while (n)
		num[len++] = n % 10, n /= 10;
	if (len == 0)
		num[len++] = 0;
	while (len--)
		putchar(num[len] + '0');
}


const int  MOD = 3;
int n;

struct Matrix{
	static const int MAXN = 900;
	int column, row;
	int a[MAXN][MAXN];
	Matrix(int m = 0, int n = 0) :column(m), row(n)
	{
		memset(a, 0, sizeof(a));
	}

	Matrix operator * (const Matrix & B) const{
		Matrix C(row, B.column);
		for (int i = 0; i < C.row; ++i)
			for (int k = 0; k < column; ++k)
				for (int j = 0; j < C.column; ++j)
					C.a[i][j] = (C.a[i][j]+ a[i][k] * B.a[k][j]) % MOD;
		return C;
	}
};

Matrix A, B;

int main(void)
{
	//freopen("input.txt", "r", stdin);
	while (read(n)){
		A.column = B.column = A.row = B.row = n;
		// printf("%d %d %d %d\n",A.column , B.column , A.row , B.row);
		for (int i = 0; i < A.row; ++i)
			for (int j = 0; j < A.column; ++j)
				read(A.a[i][j]), A.a[i][j] %= MOD;
		for (int i = 0; i < B.row; ++i)
			for (int j = 0; j < B.column; ++j)
				read(B.a[i][j]), B.a[i][j] %= MOD;
		A = A * B;
		for (int i = 0; i < A.row; ++i)
			for (int j = 0; j < A.column; ++j)
				write(A.a[i][j]), putchar(j == A.column - 1 ? '\n' : ' ');
	}
	return 0;
}

或者不用结构体，直接用裸的二维数组去做，就不需要手动扩展。

但是这样依然是TLE，仍然还需要优化。

第三版本：在网上看了资料，才明白，其实矩阵乘法也需要优化。

优化1：只在输入和输出时对每个数取余，在矩阵乘法计算过程中不进行取余运算。在计算机内部，加减乘除和取余所用的时间是不一样的，取余运算在大多数的计算机上是相当耗时的一个操作，所以我们要尽量避免取余运算的发生。第一步优化就是在矩阵乘法求和时，因为题目中首先对原来的A,B矩阵取余，得到的是每个元素将会变成0,1,2，所以即使很多数的和也不会超过int的范围。所以我们可以直接累加，在最后输出结果时，再对结果取余，从而减少取余运算的数目。

优化2：改变循环的次序，将对k的循环放到第二层，将j的循环放到第三层。原因：C/C++语言中，二维或者多维数组其实也是线性储存的。所以对于高维数组的访问，相比于从前一行到后一行的跳跃式的数据访问（指针的跳跃前进），从前往后访问数数据（指针一步一步前进）的速度要快。同时，在计算和的时候，a[i][k]是一个不变量，更好的利用了cpu里面的cache，提高命中率，加快访问速度，从而加速计算。

优化3：当某个数是0时，不需要再进行下面的计算。

最后的代码如下：

#include <cstdio>
#include <cstring>
#include <vector>
#include <cctype>

using namespace std;

template<class T>
inline bool read(T &n)
{
    T signal = 1,x = 0;
    char ch = getchar();
    while((ch <'0' || ch >'9') && ch != EOF && ch != '-')
        ch = getchar();
    if(ch == EOF)  return false;
    if(ch == '-')  ch = getchar(), signal = -1;
    while(ch <='9' && ch >='0'){
        x *= 10;
        x += ch -'0';
        ch = getchar();
    }
    n = x * signal;
    return true;
}
template<class T>
inline void write(T n)
{
    if(n < 0)
        putchar('-'), n = -n;
    int len = 0, num[20];
    while(n)
        num[len++] = n % 10, n /= 10;
    if(len == 0)
        num[len++] = 0;
    while(len--)
        putchar(num[len]+'0');
}

const int MAXN = 805;
int a[MAXN][MAXN], b[MAXN][MAXN], ans[MAXN][MAXN];
int N;

int main()
{
    //freopen("input.txt","r",stdin);
    while(read(N)){
        for(int i = 0 ; i < N; ++i)
            for(int j = 0; j < N; ++j)
                read(a[i][j]),a[i][j] %= 3;
        for(int i = 0 ; i < N; ++i)
            for(int j = 0; j < N; ++j)
                read(b[i][j]),b[i][j] %= 3;
        memset(ans,0,sizeof(ans));
        for(int i = 0 ; i < N; ++i)
            for(int k = 0; k < N; ++k)
                if(a[i][k] == 0) continue;
                else for(int j = 0; j < N; ++j)
                    ans[i][j] += a[i][k]*b[k][j];
        for(int i = 0 ; i < N; ++i)
            for(int j = 0 ; j < N; ++j)
                write(ans[i][j]%3),putchar(j == N-1?'\n':' ');
    }
    return 0;
}

最后把一些东西总结一下吧：

1.c++对scanf,printf进行了优化，使其输入输出的速度快于G++的scanf,printf。而G++对字符读入getchar,putchar进行了优化，所以可以逐个字符的读入去读取数字，但这个方法的速度非常快，上述方法在c++里没有效果。

2.对于规模非常大的数组，最好还是不用结构体封装，直接用裸的数组去完成计算。

3.C++可以手动扩栈，命令如上。

4.硬件对代码的实现也会极大的影响程序的性能。