Strassen 矩阵乘法
2024-06-03 18:35:51
快累死了，因为计算这个计算的头晕脑胀，加减乘除严重的忘记了，总算是出来了，
矩阵乘法最原始的解决手段大家都是知道的，但是算法的时间复杂度却是O（n^3），如果采用Strassen对问题的分析，在分治的基础上，计算的时间复杂度变为了O（n^2.81），废话少说，代码奉上：
public class Num1 {
public static void main(String[] args) {
int[][] nul1 = { { 1, 2, 3, 4 }, { 2, 5, 8, 9 }, { 9, 1, 4, 6 },
{ 5, 2, 3, 9 } };
int[][] nul2 = { { 5, 6, 6, 4 }, { 8, 7, 8, 7 }, { 8, 5, 2, 3 },
{ 7, 8, 9, 5 } };
// int[][] nul1 = { {5,6}, { 8,7 }};
// int[][] nul2 = { { 13,7}, {8,11} };
int length = nul1.length;
int[][] num = new int[length][length];
num = multip(nul1, nul2);
for (int i = 0; i < length; i++) {
for (int j = 0; j < length; j++)
System.out.print(num[i][j] + " ");
System.out.println();
}
}
private static int[][] multip(int[][] nul1, int[][] nul2) {
int len = nul1.length;
int[][] re = new int[len][len];
if (len == 2) {
int p = (nul1[0][0] + nul1[1][1]) * (nul2[0][0] + nul2[1][1]);
int q = nul2[0][0] * (nul1[1][0] + nul1[1][1]);
int r = nul1[0][0] * (nul2[0][1] - nul2[1][1]);
int s = nul1[1][1] * (nul2[1][0] - nul2[0][0]);
int t = (nul1[0][0] + nul1[0][1]) * nul2[1][1];
int u = (nul1[1][0] - nul1[0][0]) * (nul2[0][0] + nul2[0][1]);
int v = (nul1[0][1] - nul1[1][1]) * (nul2[1][0] + nul2[1][1]);
re[0][0] = p + s - t + v;
re[0][1] = r + t;
re[1][0] = q + s;
re[1][1] = p + r - q + u;
} else {
int[][] A1 = new int[len / 2][len / 2];
int[][] A2 = new int[len / 2][len / 2];
int[][] A3 = new int[len / 2][len / 2];
int[][] A4 = new int[len / 2][len / 2];
int[][] B1 = new int[len / 2][len / 2];
int[][] B2 = new int[len / 2][len / 2];
int[][] B3 = new int[len / 2][len / 2];
int[][] B4 = new int[len / 2][len / 2];
int i;
int j;
int index1 = len / 2;
for (i = 0; i < len / 2; i++)
for (j = 0; j < len / 2; j++) {
A1[i][j] = nul1[i][j];
B1[i][j] = nul2[i][j];
}
for (i = 0; i < len / 2; i++)
for (j = len / 2; j < len; j++) {
A2[i][j - index1] = nul1[i][j];
B2[i][j - index1] = nul2[i][j];
}
for (i = len / 2; i < len; i++)
for (j = 0; j < len / 2; j++) {
A3[i - index1][j] = nul1[i][j];
B3[i - index1][j] = nul2[i][j];
}
for (i = len / 2; i < len; i++)
for (j = len / 2; j < len; j++) {
A4[i - index1][j - index1] = nul1[i][j];
B4[i - index1][j - index1] = nul2[i][j];
}
int[][] P = new int[len / 2][len / 2];
int[][] Q = new int[len / 2][len / 2];
int[][] R = new int[len / 2][len / 2];
int[][] S = new int[len / 2][len / 2];
int[][] T = new int[len / 2][len / 2];
int[][] U = new int[len / 2][len / 2];
int[][] V = new int[len / 2][len / 2];
P = multip(add(A1, A4), add(B1, B4));
Q = multip(add(A3, A4), B1);
R = multip(A1, sub(B2, B4));
S = multip(A4, sub(B3, B1));
T = multip(add(A1, A2), B4);
U = multip(sub(A3, A1), add(B1, B2));
V = multip(sub(A2, A4), add(B3, B4));
System.out.println("----P----");
for (int m = 0; m < P.length; m++) {
for (int n = 0; n < P.length; n++)
System.out.print(P[m][n] + " ");
System.out.println();
}
System.out.println("---------");
System.out.println("----Q----");
for (int m = 0; m < Q.length; m++) {
for (int n = 0; n < Q.length; n++)
System.out.print(Q[m][n] + " ");
System.out.println();
}
System.out.println("---------");
System.out.println("----R----");
for (int m = 0; m < R.length; m++) {
for (int n = 0; n < R.length; n++)
System.out.print(R[m][n] + " ");
System.out.println();
}
System.out.println("---------");
System.out.println("----S----");
for (int m = 0; m < S.length; m++) {
for (int n = 0; n < S.length; n++)
System.out.print(S[m][n] + " ");
System.out.println();
}
System.out.println("---------");
System.out.println("----T----");
for (int m = 0; m < T.length; m++) {
for (int n = 0; n < T.length; n++)
System.out.print(T[m][n] + " ");
System.out.println();
}
System.out.println("---------");
System.out.println("----U----");
for (int m = 0; m < U.length; m++) {
for (int n = 0; n < U.length; n++)
System.out.print(U[m][n] + " ");
System.out.println();
}
System.out.println("---------");
System.out.println("----V----");
for (int m = 0; m < V.length; m++) {
for (int n = 0; n < V.length; n++)
System.out.print(V[m][n] + " ");
System.out.println();
}
System.out.println("---------");
int[][] C1 = new int[len / 2][len / 2];
int[][] C2 = new int[len / 2][len / 2];
int[][] C3 = new int[len / 2][len / 2];
int[][] C4 = new int[len / 2][len / 2];
C1 = sub(add(P, S, V), T);
C2 = add(R, T);
C3 = add(Q, S);
C4 = sub(add(P, R, U), Q);
int m, n;
int index = len / 2;
for (m = 0; m < index; m++)
for (n = 0; n < index; n++)
re[m][n] = C1[m][n];
for (m = 0; m < index; m++)
for (n = 0; n < index; n++)
re[m][n + index] = C2[m][n];
for (m = 0; m < index; m++)
for (n = 0; n < index; n++)
re[m + index][n] = C3[m][n];
for (m = 0; m < index; m++)
for (n = 0; n < index; n++)
re[m + index][n + index] = C4[m][n];
}
return re;
}
private static int[][] sub(int[][] b2, int[][] b4) {
int len = b2.length;
int[][] sub = new int[len][len];
for (int i = 0; i < len; i++)
for (int j = 0; j < len; j++)
sub[i][j] = b2[i][j] - b4[i][j];
return sub;
}
private static int[][] add(int[][] a1, int[][] a2, int[][]... arg) {
int len = a1.length;
int[][] sum = new int[len][len];
for (int i = 0; i < len; i++)
for (int j = 0; j < len; j++)
sum[i][j] = a1[i][j] + a2[i][j];
for (int i = 0; i < arg.length; i++)
for (int j = 0; j < a1.length; j++)
for (int k = 0; k < a1.length; k++)
sum[j][k] += arg[i][j][k];
return sum;
}
}
Strassen 矩阵乘法相关推荐
- 算法中的Strassen矩阵乘法
Introduction 介绍 Strassen in 1969 which gives an overview that how we can find the multiplication of ...
- 编程实现Strassen矩阵乘法
编程实现Strassen矩阵乘法 #include<stdio.h> int a[3][3] = {{1,2,3},{1,2,3},{1,2,3}, }; int b[3][3] = {{ ...
- strassen矩阵乘法c语言代码,计算机算法：Strassen矩阵乘法
简介 Strassen矩阵乘法是典型的分而治之算法.我们已经见过诸如归并排序,Karatsuba大数乘法的分而治之的算法.让我们再次领略一下分而治之的含义. 与动态编程的"分散"得 ...
- strassen矩阵乘法 java_Strassen 矩阵算法 Java 实现
展开全部 算法如下: //STRASSEN矩阵算法 #include const int N=8; //常量N用来定义矩阵的大小 void main() { void STRASSEN(int n,f ...
- 分治-Strassen矩阵乘法
A和B的乘积矩阵C中的元素C[i,j]定义为: 若依此定义来计算A和B的乘积矩阵C,则每计算C的一个元素C[i][j],需要做n次乘法和n-1次加法.因此,算出矩阵C的个元素所需的计算时间为O(n3) ...
- strassen矩阵乘法 java_矩阵乘法Strassen算法
矩阵乘法是种极其耗时的运算.以 为例,其中 和 都是 矩阵.根据矩阵乘法的定义, 中的每个元素需要按照如下方式计算 式(4.8)包含一个 次的循环,因此计算 的时间复杂度为 .而 共有 个元素,因此总 ...
- Strassen矩阵乘法(C++)
思路 两个矩阵A,B相乘时.有以下三种方法 暴力计算法. 三个for循环, 这时候时间复杂度为O(n^3).因为Cij=∑(k=1->n)Aik*Bkj,需要一个循环, 且C中有n^2个元素, ...
- 关于strassen矩阵乘法的矩阵大小不是2^k的形式时，时间复杂度是否还是比朴素算法好的看法...
原来是n,找到大于等于n且是2^k形式的数m. n*n的矩阵补全为m*m的矩阵,原来的矩阵放在最左上方,其它位置的值为0. 朴素方法:n^3 现在:m^2.8 即m/n需小于e^(3/2.8)=2.9 ...
- 《算法导论》——矩阵乘法的Strassen算法
前言: 很多朋友看到我写的<算法导论>系列,可能会觉得云里雾里,不知所云.这里我再次说明,本系列博文时配合<算法导论>一书,给出该书涉及的算法的c++实现.请结合<算法导 ...
最新文章
- 【正一专栏】欧洲五大联赛猜想（二）西甲冠绝欧洲英超继续混战
- springboot(七)：springboot+mybatis多数据源最简解决方案
- ibatise 没有大于等于吗_农村房屋没有证等于违法建筑吗？下面三个时间点记住，小心被忽悠...
- java utf8转iso8859-1_在Java中将UTF-8转换为ISO-8859-1
- 进程是如何使用内存的？
- 入门云虚拟主机，为你的业务快速实现数据备份和数据恢复
- python中的switch语句_python技巧 switch case语句
- 关于blog [转贴]来自网络
- python3的文件编码问题
- Gephi教程-根据邻接矩阵构建复杂网络有向图
- eviews建立时间序列模型_Eviews教程 Eviews进行时间序列分析教程
- dbv oracle驱动,Oracle DBV工具
- 2021-6-26 激光的工业应用
- java 日语文档翻译_日语文档怎么翻译？我来教会你日语翻译
- android java标准时间_关于android：Java中格林尼治标准时间的毫秒数
- python微控制器编程pdf_Python高性能编程 中文高清pdf完整版[17MB]
- Help Hanzo（区间素数筛）
- 工作流任务调度系统：Apache DolphinScheduler
- 从虚拟走向现实！数字孪生迎来崛起
- 全量表/增量表/快照表