Question

1我输入的内容
文件input.txt看起来像这样：

3 2
  1 2

1 2
  3 4

4 2
  1 3

1 2
  2 1

其中：
3 2个3个矩阵的文件; 2长度的矩阵（它们都是正方形）
1 2 i = 1 j =请求值的2位inmatrixResult [i] [j]

1 2矩阵1
3 4

4 2矩阵2
1 3

1 2矩阵3
2 1

矩阵的数量可以是任何<= 130 矩阵大小可以是任何<= 130

2我应该在输出上做什么
一个数字，它是结果矩阵的成员，由位置值（在这种情况下为1,2）指定其中结果矩阵=矩阵1 *矩阵2
例如，最终结果是：20

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

/**
 * Created by Pazuk on 28.01.2018.
 */

// Main idea:
// Step 1. Get all values from input file and according with it build array with numbers for matrices
// Step 2.
// Loop iteration:
// - get numbers from array and create next matrix array
// - multiply actual matrix with next matrix, get result matrix
// - mark result matrix as actual matrix
// Next iteration...
// Step 3. After last iteration, get from result matrix requested number (positions specified in input file)


public class Main {


    static int[] list;

    static boolean fileCheckOk=true;
    static int m;
    static int n;
    static int a;
    static int b;


    static int[][] matrixA;

    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        long time = System.currentTimeMillis() - startTime;
        System.out.println(time);

        readFile();

        time = System.currentTimeMillis()-startTime;
        System.out.println(time);

        if(fileCheckOk){
            calculate();

            PrintWriter writer=new PrintWriter("output.txt");
            writer.print(matrixA[a-1][b-1]);
            writer.close();
        }

        time = System.currentTimeMillis()-startTime;
        System.out.println(time);
    }

    static void readFile() throws IOException {

       Reader reader=new FileReader(file);
       StreamTokenizer tokenizer=new StreamTokenizer(reader);

       //general input values:
       tokenizer.nextToken();
       m=(int)tokenizer.nval; // number of matricis
       tokenizer.nextToken();
       n=(int)tokenizer.nval; // matrices size
       tokenizer.nextToken();
       a=(int)tokenizer.nval; // position i of requested number
       tokenizer.nextToken();
       b=(int)tokenizer.nval; // position j of requested number                

       list=new int[m*n*n]; // array length according with quantity of matricis and their size
       int i=0;
       while(tokenizer.nextToken()!=StreamTokenizer.TT_EOF){
           list[i]=(int)tokenizer.nval;
           i++;
       }

       if(reader!=null) {
               reader.close();
       }

        /*if(m>=1 && m<=130 && n>=1 && n<=130 && a>=1 && a<=n && b>=1 && b<=n){
            fileCheckOk=true;
        }*/
    }

    static void calculate(){ // calculate matrices

        int f, i, j, k;
        int r=0;
        int t;
        int temp;
        int[] thatColumn=new int[n];
        int[] thisRow=new int[n];
        int result=0;

        matrixA=new int[n][n]; // actual matrix
        for(f=0; f< m; f++){ // number of iterations==matrices quantity
            int[][] matrixB=new int[Main.n][Main.n]; // next matrix
            for(i=0; i< Main.n; i++){
                for(j=0; j< Main.n; j++){
                    matrixB[i][j]=list[r];
                    r++;
                }
            }

            if(f>0){
                int[][] matrixC=new int[Main.n][Main.n]; //result matrix

                for(j=0; j< Main.n; j++){
                    for(k=0; k< Main.n; k++){
                        thatColumn[k]=matrixB[k][j];
                    }

                    for(i=0; i< Main.n; i++){
                        thisRow=matrixA[i];
                        result=0;
                        for(k=0; k<Main.n; k++){
                            temp=thisRow[k]*thatColumn[k];                                
                            result=result+temp;                                
                        }
                         matrixC[i][j]=result;
                    }
                }

                /*for(i=0; i< Main.n; i++){
                    for(j=0; j< Main.n; j++){
                        t=matrixA[i][k];
                        for(j=0; j< Main.n; j++){
                            temp=t*matrixB[k][j]; // multiplying...                                
                            matrixC[i][j]=matrixC[i][j]+temp; // ...matrces                                
                        }
                    }
                }*/

                matrixA=matrixC;                    
            } else {
                matrixA=matrixB;                    
            }
        }
    }

}

我的代码可以正常工作并输出正确的值。但是这段代码没有通过测试。因为它的工作太慢了。

我可以做些什么来让它更快地完成？

也许＃1。从文件其他方式处理信息？现在我扫描nextInt。第一 4投入变量。全部留到int []数组中（看看readFile（）方法）。并且在获取A，B等值之后。这个数组中的矩阵。

也许＃2。改变矩阵乘法的方法？现在我这样做基本＆＃34;直接＆＃34;方式：

 for(int i=0; i<m; i++){
             for(int j=0; j<n; j++){
                 for(int k=0; k<o; k++){
                     resultMatrix[i][j]+=mA[i][k]*mB[k][j]; 
                 }
             }
         }

嗯，几乎就是这样。快一点（看看calculate（）方法）。

也许＃3。在并行线程中进行计算（或其他）？

也许＃4。而不是：＆＃34; build＆＃34;来自int []数组值的A和B矩阵首先，在尝试：计算之后将它们相乘 resultMatrix直接使用来自一维数组int []？

的值

如何加快从文件中读取矩阵并将它们相乘？

0 个答案: