2014 Multi-University Training Contest 5Matrix multiplication（HDOJ 4920）

~写在前面的话：

/*** 集训过去款一大半了，感觉就这么过来了，也许大学四年（其实还有三年）也会这么晃过去

so，写下来每天的算是激励自己吧~~

***/

~先附上官方题解（只有思路，标程到文章最后附上吧）

爱but的苍蝇（好像是HDU集训队的hj大大，认错了表打我(⊙o⊙)…）

前前后后一共做了好几次优化，看我慢慢的写来：

~第一次TEL，然后看了队友过了很郁闷自己的为什么就不行了（就是图片里的最下面那个，1765MS哇哇哇哇）（注释部分是我的，只有最里面和中间的循环换了位置，然后……）

#include<algorithm>
#include <iostream> 
#include <cstring> 
#include <string> 
#include <vector> 
#include <cstdio> 
#include <stack> 
#include <queue> 
#include <cmath>  
using namespace std;
int n,m,t;
int a[801][801],b[801][801],c[801][801];
int main()
{
    while(~scanf("%d",&n))
    {
        memset(c,0,sizeof(c));
        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;
            }

        }
        for(int i=0;i<n;i++)
        {
            for(int k=0;k<n;k++)
            {
                for(int j=0;j<n;j++)
                {
                    c[i][j]+=a[i][k]*b[k][j];
                }
            }
        }
//        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];
//                }
//            }
//        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                printf("%d",c[i][j]%3);
                if(j!=n-1)
                    printf(" ");
                else
                    printf("\n");
            }
        }
    }
    return 0;
}

然后在网上各种搜索，终于知道这个和cpu的存储啥有关： 百度库库

~第二次（图里倒数第三个）优化，是加了输入外挂：（谢这个网友啦）

~然后又加了输出外挂（主要是想测试一下速度能到什么程度，所以分开的提交）

~此时已经1100多MS了，看到有好多人都是七八百的样子，，于是问了下HDU的haipz大大，可以减掉的，也就是稀疏矩阵咯

  于是，变成了812MS哇挺有用的就是把乘的三个循环里加个if：

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

~~最后想不粗来怎么优化了，谁知道的话，告诉下

~~这个事标程，也就是第一个1600多MS的，郁闷：

#include <bitset>
#include <cassert>
#include <cstdio>
#include <cstring>
const int N = 800;
int n, a[N][N], b[N][N];
std::bitset <N> rows[3][N], columns[3][N];
int main() {
    while (scanf("%d", &n) == 1) {
        assert(1 <= n && n <= N);
        for (int _ = 1; _ < 3; ++ _) {
            for (int i = 0; i < n; ++ i) {
                for (int j = 0; j < n; ++ j) {
                    rows[_][i].reset(j);
                    columns[_][j].reset(i);
                }
            }
        }
        for (int i = 0; i < n; ++ i) {
            for (int j = 0; j < n; ++ j) {
                assert(scanf("%d", a[i] + j) == 1);
                assert(0 <= a[i][j] && a[i][j] <= 1000000000);
                a[i][j] %= 3;
                rows[a[i][j]][i].set(j);
            }
        }
        for (int i = 0; i < n; ++ i) {
            for (int j = 0; j < n; ++ j) {
                assert(scanf("%d", b[i] + j) == 1);
                assert(0 <= b[i][j] && b[i][j] <= 1000000000);
                b[i][j] %= 3;
                columns[b[i][j]][j].set(i);
            }
        }
        for (int i = 0; i < n; ++ i) {
            for (int j = 0; j < n; ++ j) {
                int result = 0;
                result += (rows[1][i] & columns[1][j]).count();
                result += (rows[1][i] & columns[2][j]).count() * 2;
                result += (rows[2][i] & columns[1][j]).count() * 2;
                result += (rows[2][i] & columns[2][j]).count();
                printf("%d%c", result % 3, " \n"[j == n - 1]);
            }
        }
    }
    return 0;
}

说真的没咋看懂（因为没学过C++，好吧这不是理由），最后的输出的样子倒是第一次见啦~