蓝桥杯 算法训练---矩阵乘法（StringTokenizer加速读取）

  算法训练 矩阵乘法  

时间限制：1.0s   内存限制：512.0MB

   

问题描述

　　输入两个矩阵，分别是m*s，s*n大小。输出两个矩阵相乘的结果。

输入格式

　　第一行，空格隔开的三个正整数m,s,n（均不超过200）。
　　接下来m行，每行s个空格隔开的整数，表示矩阵A（i，j）。
　　接下来s行，每行n个空格隔开的整数，表示矩阵B（i，j）。

输出格式

　　m行，每行n个空格隔开的整数，输出相乘後的矩阵C（i，j）的值。

样例输入

2 3 2
1 0 -1
1 1 -3
0 3
1 2
3 1

样例输出

-3 2
-8 2

提示
矩阵C应该是m行n列，其中C(i,j)等于矩阵A第i行行向量与矩阵B第j列列向量的内积。
例如样例中C(1,1)=(1,0,-1)*(0,1,3) = 1 * 0 +0*1+(-1)*3=-3

最近在做矩阵乘法，发现并算法是写出来，但是得到的评测结果只有85分，显示最后一组数据运行超时。

import java.util.*;

public class Main{	
	public static void main(String [] args)
	{
		Scanner sc=new Scanner(System.in);
		int m=sc.nextInt();
		int s=sc.nextInt();
		int n=sc.nextInt();
		int [][]a=new int[m][s];
		int [][]b=new int[s][n];
		for(int i=0;i<m;i++)
		{
			for(int j=0;j<s;j++)
			{
				a[i][j]=sc.nextInt();
			}
		}
		for(int i=0;i<s;i++)
		{
			for(int j=0;j<n;j++)
			{
				b[i][j]=sc.nextInt();
			}
		}
		int [][]c=new int[m][n];
		fun(a,b);	
	}
	public static void fun(int [][]a,int[][]b)
	{
		if(a[0].length==b.length) 
		{
			int x=a.length;
			int y=b[0].length;
			int [][]c=new int[x][y];
			for(int i=0;i<x;i++)
			{
				for(int j=0;j<y;j++)
				{
					for(int k=0;k<b.length;k++)
					{
						c[i][j]+=a[i][k]*b[k][j];
					}
					System.out.print(c[i][j]+" ");
				}
				System.out.println();
			}
		}
    }  
}

       一开始我还以为是循环导致超时，但是也暂时想不到有什么好的办法替换循环或者减少循环。然后就百度看看有什么好的办法解决这个超时的问题。发现大部分人用C语言解决矩阵乘法是没有出现这个超时的问题的，但是用Java语言就会出现超时。

     百度了一大堆东西之后，发现有人提议说是Java的输入/输出与C语言相比的最慢的一部分，然后我就想那可能是矩阵输入数据太多的时候超时了，就改用了另一种办法输入数据（我一开始是使用Scanner进行读取数据的），后来使用BufferedReader+StringTokenizer进行读取数据，提交之后发现通过了。

package Lanqiaobei;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

public class Main{	
	public static void main(String [] args)  throws IOException 
	{
		 Reader.init(System.in); //将Reader连接到输入流
	     int m = Reader.nextInt();
	     int s = Reader.nextInt();
	     int n = Reader.nextInt();
	     int [][]a=new int[m][s];
	     int [][]b=new int[s][n];
	     //以数组的形式输入两个矩阵
		for(int i=0;i<m;i++)
		{
			for(int j=0;j<s;j++)
			{
				a[i][j]=Reader.nextInt();
			}
		}
		for(int i=0;i<s;i++)
		{
			for(int j=0;j<n;j++)
			{
				b[i][j]=Reader.nextInt();
			}
		}
		int [][]c=new int[m][n];
		fun(a,b);	
	}
	/**实现两个矩阵相乘*/
	public static void fun(int [][]a,int[][]b)
	{
		if(a[0].length==b.length) 
		{
			int x=a.length;
			int y=b[0].length;
			int [][]c=new int[x][y];
			for(int i=0;i<x;i++)
			{
				for(int j=0;j<y;j++)
				{
					for(int k=0;k<b.length;k++)
					{
						c[i][j]+=a[i][k]*b[k][j];
					}
					System.out.print(c[i][j]+" ");
				}
				System.out.println();
			}
		}
    }  
}

/**缓冲读取int*/
class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /**调用此方法初始化InputStream读取器*/
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }

    /**获取下一个字*/
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
	
}

 

       在这个例子当中，可以推测出，当读取大量数据的时候，Buffer额度Reader+StringTokenizer比较Scanner读取要快。在改进当中，我参考了别人的方法，为了提高Java的代码的可重用性，把代码放在一个单独的类当中，这样会方便我们以后使用。

参考链接：https://www.cpe.ku.ac.th/~jim/java-io.html