• 2021-02-26 11:06:39

publicclassMatrix{int[][]a;int[][]b;publicMatrix(int[][]x,int[][]y){int[][]a=x;int[][]b=y;}publicMatrixBiMatrix(){intx=a.length;inty=b[0].length;into=b.length;intz[][]=ne...

public class Matrix {

int[][] a;

int[][] b;

public Matrix(int [][]x,int [][]y) {

int[][]a=x;

int[][]b=y;

}

public Matrix BiMatrix(){

int x=a.length;

int y=b[0].length;

int o=b.length;

int z[][]=new int[x][y];

for(int xx=0;xx

for(int yy=0;yy

int result=0;

for(int oo=0;00

result=result+a[xx][oo]*b[oo][yy];

}

z[xx][yy]=result;

}

}

}

for(int xx=0;xx

for(int yy=0;yy

System.out.println(z[xx][yy]);

}

}

return z;

} 两个矩阵相乘，好像是返回值和方法的类型弄错了 编译报错，大侠救命啊！

展开

更多相关内容
• Java实现矩阵相乘 package com.company; public class Matrix { public int row; public int col; public double[][] data; Matrix(double[][] array){ //获得矩阵的行与列数 this.row=array.length; this....

### Java实现矩阵相乘

package com.company;

public class Matrix {
public int row;
public int col;
public double[][] data;
Matrix(double[][] array){
//获得矩阵的行与列数
this.row=array.length;
this.col=array[0].length;
//为data申请空间
this.data=new double[row][col];
//遍历数组进行数组复制
for(int i=0;i<row;i++){
System.arraycopy(array[i], 0, this.data[i], 0, col);
}
}
//矩阵乘法
public Matrix multiply(Matrix B){
//构造返回结果矩阵
Matrix C=new Matrix(new double[this.row][B.col]);
//遍历A矩阵的行
for(int A_row=0;A_row<this.row;A_row++){
//遍历B的列与行相乘求和
for(int B_col=0;B_col<B.col;B_col++) {
double sum = 0d;
for (int A_col = 0; A_col < this.col; A_col++) {
sum += this.data[A_row][A_col] * B.data[A_col][B_col];
}
C.data[A_row][B_col] = sum;
}
}
return C;
}
//重写toString方法
@Override
public String toString(){
String  result="[\n";
for(int i=0;i<this.row;i++){
result+="[";
for(int j=0;j<this.col;j++){
//将this.data[i][j]保留三位小数,转为字符串+" "
result+=String.format("%.3f ", this.data[i][j]);
}
result+="]\n";
}
result+="]";
return result;
}
}


展开全文
• import java.util.Scanner;public class a132 {public static void main(String args[]) {Scanner in = new Scanner(System.in);while (in.hasNext()) {int m = in.nextInt();int n = in.nextInt();int...

package a123;

import java.util.Scanner;

public class a132 {

public static void main(String args[]) {

Scanner in = new Scanner(System.in);

while (in.hasNext()) {

int m = in.nextInt();

int n = in.nextInt();

int n1 = in.nextInt();

double a[][] = new double[m + 1][n + 1];

double b[][]= new double[n + 1][n1 + 1];

double c[][] = new double[m + 1][n1 + 1];

for (int i = 1; i <= m; i++) {

for (int j = 1; j <= n; j++) {

a[i][j] = in.nextDouble();

}

System.out.println();

}

System.out.println();

System.out.println();

for (int i = 1; i <= n; i++) {

for (int j = 1; j <= n1; j++) {

b[i][j] = in.nextDouble();

}

System.out.println();

}

System.out.println();

System.out.println();

for (int i = 1; i <= m; i++) {

for (int j = 1; j <= n1; j++) {

c[i][j] = 0;

for (int k = 1; k <= n; k++) {

c[i][j] += a[i][k] * b[k][j];

}

System.out.printf("%10.2f", c[i][j]);

}

System.out.println();

}

}

}

}

展开全文
• ## Java实现矩阵相乘问题

万次阅读 多人点赞 2019-07-15 20:50:24
1 问题描述 1.1实验题目 设M1和M2是两个n×n的矩阵，设计算法计算M1×M2 的乘积。 1.2实验目的 （1）提高应用蛮力法设计算法的技能；...（1）设计并实现用BF(Brute-Force，即蛮力法)方法求解矩阵相乘问题...

1 问题描述
1.1实验题目
设M1和M2是两个n×n的矩阵，设计算法计算M1×M2 的乘积。

1.2实验目的
（1）提高应用蛮力法设计算法的技能；

（2）深刻理解并掌握分治法的设计思想；

（3）理解这样一个观点：用蛮力法设计的算法，一般来说，经过适度的努力后，都可以对其进行改进，以提高算法的效率。


1.3实验要求
（1）设计并实现用BF(Brute-Force，即蛮力法)方法求解矩阵相乘问题的算法；

（2）设计并实现用DAC（Divide-And-Conquer，即分治法）方法求解矩阵相乘问题的算法；

（3）以上两种算法的输入既可以手动输入，也可以自动生成；

（4）对上述两个算法进行时间复杂性分析，并设计实验程序验证分析结果；

（5）设计可供用户选择算法的交互式菜单(放在相应的主菜单下)。


2 解决方案
2.1 分治法原理简述
分治法的设计思想是：将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

分治策略是：对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。

如果原问题可分割成k个子问题，1<k≤n ，且这些子问题都可解并可利用这些子问题的解求出原问题的解，那么这种分治法就是可行的。由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。在这种情况下，反复应用分治手段，可以使子问题与原问题类型一致而其规模却不断缩小，最终使子问题缩小到很容易直接求出其解。这自然导致递归过程的产生。分治与递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。

分治法所能解决的问题一般具有以下几个特征：

1. 该问题的规模缩小到一定的程度就可以容易地解决

2. 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。

3. 利用该问题分解出的子问题的解可以合并为该问题的解；

4. 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题。

2.2 分治法求解矩阵相乘原理
首先了解一下传统计算矩阵相乘的原理：

其次，看一下优化后的矩阵相乘法原理：

最后，看一下本文利用分治法求解矩阵相乘的原理（ＰＳ：本文求解其效率不是最高，主要是体验一下分治法，重点在于分治法）：

注意：使用分治法求解两个nxn阶矩阵相乘，其中n值为2的幂值，否则只能使用蛮力法计算。

本文具体源码主要根据以上分块矩阵方法，先分块（即使用分治法），然后递归求解。

2.3 具体实现源码

package com.liuzhen.dac;

public class Matrix {

//初始化一个随机nxn阶矩阵
public static int[][] initializationMatrix(int n){
int[][] result = new int[n][n];
for(int i = 0;i < n;i++){
for(int j = 0;j < n;j++){
result[i][j] = (int)(Math.random()*10); //采用随机函数随机生成1~10之间的数
}
}
return result;
}

//蛮力法求解两个nxn和nxn阶矩阵相乘
public static int[][] BruteForce(int[][] p,int[][] q,int n){
int[][] result = new int[n][n];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
result[i][j] = 0;
for(int k=0;k<n;k++){
result[i][j] += p[i][k]*q[k][j];
}
}
}
return result;
}

//分治法求解两个nxn和nxn阶矩阵相乘
public static int[][] DivideAndConquer(int[][] p,int[][] q,int n){
int[][] result = new int[n][n];
//当n为2时，返回矩阵相乘结果
if(n == 2){
result = BruteForce(p,q,n);
return result;
}

//当n大于3时，采用采用分治法，递归求最终结果
if(n > 2){
int m = n/2;

int[][] p1 = QuarterMatrix(p,n,1);
int[][] p2 = QuarterMatrix(p,n,2);
int[][] p3 = QuarterMatrix(p,n,3);
int[][] p4 = QuarterMatrix(p,n,4);
//            System.out.println();
//            System.out.print("矩阵p1值为：");
//            PrintfMatrix(p1,m);
//            System.out.println();
//            System.out.print("矩阵p2值为：");
//            PrintfMatrix(p2,m);
//            System.out.println();
//            System.out.print("矩阵p3值为：");
//            PrintfMatrix(p3,m);
//            System.out.println();
//            System.out.print("矩阵p4值为：");
//            PrintfMatrix(p4,m);

int[][] q1 = QuarterMatrix(q,n,1);
int[][] q2 = QuarterMatrix(q,n,2);
int[][] q3 = QuarterMatrix(q,n,3);
int[][] q4 = QuarterMatrix(q,n,4);

int[][] result1 = QuarterMatrix(result,n,1);
int[][] result2 = QuarterMatrix(result,n,2);
int[][] result3 = QuarterMatrix(result,n,3);
int[][] result4 = QuarterMatrix(result,n,4);

result = TogetherMatrix(result1,result2,result3,result4,m);
}
return result;
}

//获取矩阵的四分之一，并决定返回哪一个四分之一
public static int[][] QuarterMatrix(int[][] p,int n,int number){
int rows = n/2;   //行数减半
int cols = n/2;   //列数减半
int[][] result = new int[rows][cols];
switch(number){
case 1 :
{
// result = new int[rows][cols];
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
result[i][j] = p[i][j];
}
}
break;
}

case 2 :
{
// result = new int[rows][n-cols];
for(int i=0;i<rows;i++){
for(int j=0;j<n-cols;j++){
result[i][j] = p[i][j+cols];
}
}
break;
}

case 3 :
{
// result = new int[n-rows][cols];
for(int i=0;i<n-rows;i++){
for(int j=0;j<cols;j++){
result[i][j] = p[i+rows][j];
}
}
break;
}

case 4 :
{
// result = new int[n-rows][n-cols];
for(int i=0;i<n-rows;i++){
for(int j=0;j<n-cols;j++){
result[i][j] = p[i+rows][j+cols];
}
}
break;
}

default:
break;
}

return result;
}

//把均分为四分之一的矩阵，聚合成一个矩阵，其中矩阵a,b,c,d分别对应原完整矩阵的四分中1、2、3、4
public static int[][] TogetherMatrix(int[][] a,int[][] b,int[][] c,int[][] d,int n){
int[][] result = new int[2*n][2*n];
for(int i=0;i<2*n;i++){
for(int j=0;j<2*n;j++){
if(i<n){
if(j<n){
result[i][j] = a[i][j];
}
else
result[i][j] = b[i][j-n];
}
else{
if(j<n){
result[i][j] = c[i-n][j];
}
else{
result[i][j] = d[i-n][j-n];
}
}
}
}

return result;
}

//求两个矩阵相加结果
public static int[][] AddMatrix(int[][] p,int[][] q,int n){
int[][] result = new int[n][n];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
result[i][j] = p[i][j]+q[i][j];
}
}
return result;
}

//控制台输出矩阵
public static void PrintfMatrix(int[][] matrix,int n){
for(int i=0;i<n;i++){
System.out.println();
for(int j=0;j<n;j++){
System.out.print("\t");
System.out.print(matrix[i][j]);
}
}

}

public static void main(String args[]){
int[][] p = initializationMatrix(8);
int[][] q = initializationMatrix(8);
System.out.print("矩阵p初始化值为：");
PrintfMatrix(p,8);
System.out.println();
System.out.print("矩阵q初始化值为：");
PrintfMatrix(q,8);

int[][] bf_result = BruteForce(p,q,8);
System.out.println();
System.out.print("蛮力法计算矩阵p*q结果为：");
PrintfMatrix(bf_result,8);

int[][] dac_result = DivideAndConquer(p,q,8);
System.out.println();
System.out.print("分治法计算矩阵p*q结果为：");
PrintfMatrix(dac_result,8);
}

}


2.4 运算结果截图

展开全文
• java写的二维矩阵相乘算法，控制台程序，要求用户输入行数及列数，自动生成二维数组相乘
• 矩阵相乘最重要的方法是一般矩阵乘积。它只有在第一个矩阵的列数（column）和第二个矩阵的行数（row）相同时才有意义。一般单指矩阵乘积时，指的便是一般矩阵乘积。一个m×n的矩阵就是m×n个数排成m行n列的一个数阵...
• 编写两个矩阵相乘的方法：publicstaticdouble[][] multiplyMatrix(double[][] a, double[][] b) 编写一个测试程序，提示用户输入两个3*3的矩阵，然后显示它们的乘积。 测试数据： Enter matrix1: 1 2 3 4 5 6 7 8...
• ## Java实现矩阵相乘

千次阅读 2017-05-15 23:42:59
大一刚学Java的时候，当时也学了线性代数这门课，在方程组基础向矩阵转换的思想方法上，感觉矩阵计算比较麻烦，所以当时一直想写一个小程序来通过输入两个矩阵输出相应的相乘之后的结果矩阵。鉴于当时刚刚接手Java，...
• 算法提高 矩阵相乘 时间限制：1.0s 内存限制：256.0MB 问题描述 　小明最近在为线性代数而头疼，线性代数确实很抽象（也很无聊），可惜他的老师正在讲这矩阵乘法这一段内容。 　当然，小明上课打瞌睡也没问题，...
• 本文对当今最主流的两种编程语言C#和Java进行了对比研究,就其可移植性和运算速度两方面特性作了分析,这样的研究结果有助于更深刻地了解两种语言的特性,并且通过矩阵相乘的运算,对两种语言编写的程序性能进行了定量的...
• java矩阵相乘
• 前言我们都知道矩阵相乘的规则，矩阵1的m行与矩阵2的n列对应的位置的乘积之和即为结果矩阵m行n列的值，所以只有当矩阵1的列数等于矩阵2的行数时，才可以进行相乘。其实矩阵的本质是线性方程式的表示形式，比如： ...
• Java codeclass Matrix { int rows; int cols; double data[][]; public Matrix() { } public Matrix(int rows, int cols) { this.rows = rows; this.cols = cols; data = n...
• 　给定一个N阶矩阵A，输出A的M次幂（M是非负整数） 　例如： 　A = 　1 2 　3 4 　A的2次幂 　7 10 　15 22 输入格式 　第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数 　...
• 输出两个矩阵相乘的结果。 输入 输入描述: 　第一行，空格隔开的三个正整数m,s,n（均不超过200）。 　接下来m行，每行s个空格隔开的整数，表示矩阵A（i，j）。 　接下来s行，每行n个空格隔开的整数，表示矩阵B（i，j...
• Mat矩阵点乘——A*BOpencv重载了运算符“*”，姑且称之为Mat矩阵“点乘”，其中一... A*B是以数学运算中矩阵相乘的方式实现的，即Mat矩阵A和B被当做纯粹的矩阵做乘法运算，这就要求A的列数等 于B的行数时，才能定义...
• 为了使矩阵a能够和矩阵b相乘矩阵a的列数必须与矩阵b的行数相同，并且两个矩阵的元素要具有相同或兼容的数据类型。假设矩阵c是相乘的结果，而a的列数是n，那么每个元素c[ij]=a[i1]*b[1j]+······+a[in]*b[nj]...
• ## java实现矩阵相乘

千次阅读 2015-05-07 15:27:43
众所周知，矩阵的乘法就是矩阵的行列相乘再相加。话不多说，直接上代码： package test; public class matrixMultiply { public static void printMatrix(int[][] a, int[][] b) { int r = a.length; int c ...
• ## java矩阵乘法算法

千次阅读 2019-02-04 00:28:25
* 矩阵乘法流程是第一个矩阵的每一行与第二个矩阵的每一列中的数相乘并相加得到最终结果矩阵 * 那么就需要分三个循环来完成 * 第一个循环控制第一个矩阵的行数 * 第二个循环控制第二个矩阵的列数 * 第三个循环...
• protected void Page_Load(object sender, ...}//floor向下取整//ceiling 向上取整//开平方就用Math.Sqrt, 开n次方:Math.Pow(double, 1/n)//一维数组存储二维矩阵N*N，得到行和列// 行：i / n ；列：i % npriv...
• java编写的两个矩阵相乘的算法，打包文件，class
• 编写二个矩阵相乘的方法，方法头为： public static double[][] multiplyMatrix(double[][] a,double[][] b) 这里a的列数必须等于b的行数。 要求：提示输入m*n的矩阵a和n*k的矩阵b,m、n、k的值由用户输入，a和b的...
• 矩阵C的第一个元素C[0][0]是，矩阵A的第一行A[0][*]的每一个元素和矩阵B第一列B[*][0]的每一个对应元素的乘积，然后再对这些乘积累加求和，这个求和的结果就是矩阵C第一个元素的值.即C[0][0]=A[0][0]*B[0][0]+A[0][1...
• 里面包含好几个实验内容。。有矩阵对换。。相乘。。。
• ## 矩阵乘法Java实现

千次阅读 2021-02-18 15:37:15
本文介绍几种方式实现矩阵相乘。矩阵概念一般语言没有提供，我们首先子句实现，同时也介绍一些现成库实现。 1. 概念介绍 首先通过示例介绍矩阵，首先定义第一个3x2的矩阵： 我们再定义第二个2x3的矩阵： 两个矩阵...

...

java 订阅