《算法导论》学习心得（二）—— 矩阵乘法之Strassen算法
2014-10-31 22:23
751 查看
在开始之前，请点击下载源码。提起矩阵乘法，你也许会说不就是三次循环就解决问题了吗，这有什么好说的。是啊，三个循环确实是完事了，时间效率是O(n^3),这是我们上第一节线代老师就清清楚楚的告诉我们的，但是他没有告诉你还有比这更好的矩阵乘法，时间效率为
，也许你觉得这没有什么，就提高了0.2几，没啥，但是你想过没有，当N=100,10000的时候呢，Strassen算法和传统方法又有多少差别呢，让我们来看一下Strassen算法和传统方法的效率对比图：
通过图我们会发现Strassen算法在N超过50的时候就开始表现出明显的优势，然而现实生产中矩阵都是上百阶的，那Strassen算法更是占有绝对的优势，所以我们今天就很有必要学习Strassen算法，那下面就开始进入正题。
Strassen算法
1969年，德国的一位数学家Strassen证明O（N^3）的解法并不是矩阵乘法的最优算法，他做了一系列工作使得最终的时间复杂度降低到了O(n^2.80)。那他是怎么做到的呢？对于矩阵乘法 C = A × B，通常的做法是将矩阵进行分块相乘，如下图所示：
从上图可以看出这种分块相乘总共用了8次乘法，要改进算法计算时间的复杂度，必须减少乘法运算次数。按分治法的思想，Strassen提出一种新的方法，用７次乘法完成２阶矩阵的乘法，算法如下：
M1 = A11(B12 - B12)
M2 = (A11 + A12)B22
M3 = (A21 + A22)B11
M4 = A22(B21 - B11)
M5 = (A11 + A22)(B11 + B22)
M6 = (A12 - A22)(B21 + B22)
M7 = (A11 - A21)(B11 + B12)
完成了７次乘法，再做如下加法：
C11 = M5 + M4 - M2 + M6
C12 = M1 + M2
C21 = M3 + M4
C22 = M5 + M1 - M3 - M7
全部计算使用了７次乘法和１８次加减法，计算时间降低到O(nE2.81)。计算复杂性得到较大改进。
具体代码实现如下：
完整代码：
，也许你觉得这没有什么，就提高了0.2几，没啥，但是你想过没有，当N=100,10000的时候呢，Strassen算法和传统方法又有多少差别呢，让我们来看一下Strassen算法和传统方法的效率对比图：
通过图我们会发现Strassen算法在N超过50的时候就开始表现出明显的优势，然而现实生产中矩阵都是上百阶的，那Strassen算法更是占有绝对的优势，所以我们今天就很有必要学习Strassen算法，那下面就开始进入正题。
Strassen算法
1969年，德国的一位数学家Strassen证明O（N^3）的解法并不是矩阵乘法的最优算法，他做了一系列工作使得最终的时间复杂度降低到了O(n^2.80)。那他是怎么做到的呢？对于矩阵乘法 C = A × B，通常的做法是将矩阵进行分块相乘，如下图所示：
从上图可以看出这种分块相乘总共用了8次乘法，要改进算法计算时间的复杂度，必须减少乘法运算次数。按分治法的思想，Strassen提出一种新的方法，用７次乘法完成２阶矩阵的乘法，算法如下：
M1 = A11(B12 - B12)
M2 = (A11 + A12)B22
M3 = (A21 + A22)B11
M4 = A22(B21 - B11)
M5 = (A11 + A22)(B11 + B22)
M6 = (A12 - A22)(B21 + B22)
M7 = (A11 - A21)(B11 + B12)
完成了７次乘法，再做如下加法：
C11 = M5 + M4 - M2 + M6
C12 = M1 + M2
C21 = M3 + M4
C22 = M5 + M1 - M3 - M7
全部计算使用了７次乘法和１８次加减法，计算时间降低到O(nE2.81)。计算复杂性得到较大改进。
具体代码实现如下：
//Strassen二阶矩阵的乘法
static int[][] twostrassenMatrixMultiply(int [][]x,int [][]y) //阶数为2的矩阵乘法
{
int matrixXColumnLength = x[0].length;
int matrixYRowLength = x.length;//获取矩阵的行长度
if(matrixXColumnLength!=matrixYRowLength)
{
throw new RuntimeException("matrixXColumnLength!=matrixYRowLength，无法进行乘法计算！");
}
int p1,p2,p3,p4,p5,p6,p7;//这些都是按照算法定义进行的
int [][]result = new int[2][2];
p1=(y[0][1] - y[1][1]) * x[0][0];
p2=y[1][1] * (x[0][0] + x[0][1]);
p3=(x[1][0] + x[1][1]) * y[0][0];
p4=x[1][1] * (y[1][0] - y[0][0]);
p5=(x[0][0] + x[1][1]) * (y[0][0]+y[1][1]);
p6=(x[0][1] - x[1][1]) * (y[1][0]+y[1][1]);
p7=(x[0][0] - x[1][0]) * (y[0][0]+y[0][1]);
result[0][0] = p5 + p4 - p2 + p6;
result[0][1] = p1 + p2;
result[1][0] = p3 + p4;
result[1][1] = p5 + p1 - p3 - p7;
return result;
}整个计算过程为：static int[][] strassenMatrixMultiply(int [][]x,int [][]y) //矩阵乘法方法
{
if(x.length==2)
{
return twostrassenMatrixMultiply(x,y);
}
else
{
int matrixLength = x.length/2;
int[][] a11,a12,a21,a22;
a11 = new int[matrixLength][matrixLength];
a12 = new int[matrixLength][matrixLength];
a21 = new int[matrixLength][matrixLength];
a22 = new int[matrixLength][matrixLength];
int[][] b11,b12,b21,b22;
b11 = new int[matrixLength][matrixLength];
b12 = new int[matrixLength][matrixLength];
b21 = new int[matrixLength][matrixLength];
b22 = new int[matrixLength][matrixLength];
int[][] c11,c12,c21,c22,c;
c11 = new int[matrixLength][matrixLength];
c12 = new int[matrixLength][matrixLength];
c21 = new int[matrixLength][matrixLength];
c22 = new int[matrixLength][matrixLength];
c = new int[2*matrixLength][2*matrixLength];
int[][] m1,m2,m3,m4,m5,m6,m7;
divide(x,a11,a12,a21,a22); //拆分A、B、C矩阵
divide(y,b11,b12,b21,b22);
divide(c,c11,c12,c21,c22);
m1=strassenMatrixMultiply(a11,matrixMinus(b12,b22));
m2=strassenMatrixMultiply(matrixPlus(a11,a12),b22);
m3=strassenMatrixMultiply(matrixPlus(a21,a22),b11);
m4=strassenMatrixMultiply(a22,matrixMinus(b21,b11));
m5=strassenMatrixMultiply(matrixPlus(a11,a22),matrixPlus(b11,b22));
m6=strassenMatrixMultiply(matrixMinus(a12,a22),matrixPlus(b21,b22));
m7=strassenMatrixMultiply(matrixMinus(a11,a21),matrixPlus(b11,b12));
c11=matrixPlus(matrixMinus(matrixPlus(m5,m4),m2),m6);
c12=matrixPlus(m1,m2);
c21=matrixPlus(m3,m4);
c22=matrixMinus(matrixMinus(matrixPlus(m5,m1),m3),m7);
c=merge(c11,c12,c21,c22); //合并C矩阵
return c;
}
}上面就是整个算法的实现过程，欢迎大家前来讨论tangboneu@foxmail.com。完整代码：
package com.tangbo;
import java.util.Random;
import java.util.Scanner;
/*
* @Author:唐波
* Strassen矩阵乘法
* 2014.10.31
* 程序对比了传统方法和Strassen算法计算的结果是否相等
* 算法来源：1969年，德国的一位数学家Strassen证明O（N^3）的解法并不是矩阵乘法的最优算法，他做了一系列工作使得最终的时间复杂度降低到了O(n^2.80)
*/
public class SquareMatrixMultiply {
static Random random = new Random();
static Scanner in;
public static void main(String[] args)
{
int matrixLength=0;
in = new Scanner(System.in);
System.out.print("输入矩阵的阶数: ");
matrixLength = in.nextInt();
if(isEven(matrixLength)==0)
{
int [][]x=productMatrix(matrixLength);
int [][]y=productMatrix(matrixLength);
System.out.println("x矩阵:");
printMatrix(x);
System.out.println("y矩阵:");
printMatrix(y);
int [][]strassenResult =strassenMatrixMultiply(x,y);//Strassen计算结果
System.out.println("Strassen计算结果:");
printMatrix(strassenResult);
int [][] forceResult = forceMatrixMultiply(x, y);//传统方法计算结果
System.out.println("传统计算结果:");
printMatrix(forceResult);
boolean isEqual = isEqual(forceResult, strassenResult);//比较两种计算结果是否相等
if(isEqual)
{
System.out.println("两个计算结果相等！");
}else
{
System.err.println("两个计算结果不相等！");
System.exit(0);//程序退出
}
}else
{
System.out.println("矩阵不是2^k方阵，无法计算！");
}
}
static boolean isEqual(int [][]x,int [][]y)//遍历判断两个矩阵是否相等
{
boolean equal=true;
for(int i =0;i<x.length;i++)
{
for(int j=0;j<x[0].length;j++)
{
if(x[i][j]!=y[i][j])
{
equal=false;
}
}
}
return equal;
}
static int isEven(int n)//判断输入矩阵阶数是否为2^k
{
int a = 1,temp=n;
while(temp%2==0)
{
if(temp%2==0)
temp/=2;
}
if(temp==1)
a=0;
return a;
}
static int[][] productMatrix(int matrixLength)//自动生成矩阵
{
int matrix[][] = new int[matrixLength][matrixLength];
//初始化矩阵
for(int i=0;i<matrixLength;i++)
{
for(int j=0;j<matrixLength;j++)
{
matrix[i][j] = (int)(Math.random()*10);
}
}
System.out.println();
return matrix;
}
static void printMatrix(int matrix[][])//矩阵打印函数
{
int matrixRowLength = matrix.length;//获取矩阵的行数
int matrixColumnLength = matrix[0].length;//获取矩阵的列数
for(int i=0;i<matrixRowLength;i++)
{
for(int j=0;j<matrixColumnLength;j++)
{
System.out.print(matrix[i][j]+" ");
}
System.out.println();
}
}
static int[][] matrixPlus(int[][] x,int[][] y) //矩阵加法
{
int matrixXRowLength = x.length;//获取矩阵的行长度
int matrixXColumnLength = x[0].length;
int matrixYRowLength = x.length;//获取矩阵的行长度
int matrixYColumnLength = x[0].length;
if(matrixXColumnLength!=matrixYColumnLength || matrixXRowLength!=matrixYRowLength)//判断矩阵是否同型
{
throw new RuntimeException("矩阵不同型，无法进行加法计算！");
}
int[][] result = new int[matrixXRowLength][matrixXColumnLength];
for(int i=0;i<matrixXColumnLength;i++)
{
for (int j = 0; j < matrixXColumnLength; j++)
{
result[i][j] = x[i][j]+y[i][j];
}
}
return result;
}
static int[][] matrixMinus(int[][] x,int[][] y)//矩阵减法
{
int matrixXRowLength = x.length;//获取矩阵的行长度
int matrixXColumnLength = x[0].length;
int matrixYRowLength = x.length;//获取矩阵的行长度
int matrixYColumnLength = x[0].length;
if(matrixXColumnLength!=matrixYColumnLength || matrixXRowLength!=matrixYRowLength)
{
throw new RuntimeException("矩阵不同型，无法进行减法计算！");
}
int[][] result = new int[matrixXRowLength][matrixXColumnLength];
for(int i=0;i<matrixXColumnLength;i++)
{
for (int j = 0; j < matrixXColumnLength; j++)
{
result[i][j] = x[i][j]-y[i][j];
}
}
return result;
}
//Strassen二阶矩阵的乘法 static int[][] twostrassenMatrixMultiply(int [][]x,int [][]y) //阶数为2的矩阵乘法 { int matrixXColumnLength = x[0].length; int matrixYRowLength = x.length;//获取矩阵的行长度 if(matrixXColumnLength!=matrixYRowLength) { throw new RuntimeException("matrixXColumnLength!=matrixYRowLength，无法进行乘法计算！"); } int p1,p2,p3,p4,p5,p6,p7;//这些都是按照算法定义进行的 int [][]result = new int[2][2]; p1=(y[0][1] - y[1][1]) * x[0][0]; p2=y[1][1] * (x[0][0] + x[0][1]); p3=(x[1][0] + x[1][1]) * y[0][0]; p4=x[1][1] * (y[1][0] - y[0][0]); p5=(x[0][0] + x[1][1]) * (y[0][0]+y[1][1]); p6=(x[0][1] - x[1][1]) * (y[1][0]+y[1][1]); p7=(x[0][0] - x[1][0]) * (y[0][0]+y[0][1]); result[0][0] = p5 + p4 - p2 + p6; result[0][1] = p1 + p2; result[1][0] = p3 + p4; result[1][1] = p5 + p1 - p3 - p7; return result; }
static void divide(int[][] a,int[][] a11,int[][] a12,int[][] a21,int[][] a22)//分解矩阵
{
int matrixLength = a.length/2;
for(int i=0;i<matrixLength;i++)
for(int j=0;j<matrixLength;j++)
{
a11[i][j]=a[i][j];
a12[i][j]=a[i][j+matrixLength];
a21[i][j]=a[i+matrixLength][j];
a22[i][j]=a[i+matrixLength][j+matrixLength];
}
}
static int[][] merge(int [][]a11,int [][]a12,int [][]a21,int [][]a22)//合并矩阵
{
int n=a11.length;
int [][] result = new int[2*n][2*n];
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
result[i][j]=a11[i][j];
result[i][j+n]=a12[i][j];
result[i+n][j]=a21[i][j];
result[i+n][j+n]=a22[i][j];
}
}
return result;
}
static int[][] strassenMatrixMultiply(int [][]x,int [][]y) //矩阵乘法方法 { if(x.length==2) { return twostrassenMatrixMultiply(x,y); } else { int matrixLength = x.length/2; int[][] a11,a12,a21,a22; a11 = new int[matrixLength][matrixLength]; a12 = new int[matrixLength][matrixLength]; a21 = new int[matrixLength][matrixLength]; a22 = new int[matrixLength][matrixLength]; int[][] b11,b12,b21,b22; b11 = new int[matrixLength][matrixLength]; b12 = new int[matrixLength][matrixLength]; b21 = new int[matrixLength][matrixLength]; b22 = new int[matrixLength][matrixLength]; int[][] c11,c12,c21,c22,c; c11 = new int[matrixLength][matrixLength]; c12 = new int[matrixLength][matrixLength]; c21 = new int[matrixLength][matrixLength]; c22 = new int[matrixLength][matrixLength]; c = new int[2*matrixLength][2*matrixLength]; int[][] m1,m2,m3,m4,m5,m6,m7; divide(x,a11,a12,a21,a22); //拆分A、B、C矩阵 divide(y,b11,b12,b21,b22); divide(c,c11,c12,c21,c22); m1=strassenMatrixMultiply(a11,matrixMinus(b12,b22)); m2=strassenMatrixMultiply(matrixPlus(a11,a12),b22); m3=strassenMatrixMultiply(matrixPlus(a21,a22),b11); m4=strassenMatrixMultiply(a22,matrixMinus(b21,b11)); m5=strassenMatrixMultiply(matrixPlus(a11,a22),matrixPlus(b11,b22)); m6=strassenMatrixMultiply(matrixMinus(a12,a22),matrixPlus(b21,b22)); m7=strassenMatrixMultiply(matrixMinus(a11,a21),matrixPlus(b11,b12)); c11=matrixPlus(matrixMinus(matrixPlus(m5,m4),m2),m6); c12=matrixPlus(m1,m2); c21=matrixPlus(m3,m4); c22=matrixMinus(matrixMinus(matrixPlus(m5,m1),m3),m7); c=merge(c11,c12,c21,c22); //合并C矩阵 return c; } }
static int[][] forceMatrixMultiply(int [][]x,int [][]y)
{
int matrixXRowLength = x.length;//获取矩阵的行长度
int matrixXColumnLength = x[0].length;
int matrixYRowLength = x.length;//获取矩阵的行长度
int matrixYColumnLength = x[0].length;
if(matrixXColumnLength!=matrixYRowLength)
{
throw new RuntimeException("matrixXColumnLength!=matrixYRowLength，无法进行乘法计算！");
}
int [][] result = new int[matrixXRowLength][matrixYColumnLength];
for(int i=0;i<matrixXRowLength;i++)
{
for(int j=0;j<matrixYColumnLength;j++)
{
result[i][j]=0;
for(int k=0;k<matrixYRowLength;k++)
{
result[i][j] = result[i][j]+x[i][k]*y[k][j];
}
}
}
return result;
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 算法导论学习——分治矩阵乘法
- 算法导论-矩阵乘法-strassen算法
- 学习心得:《十个利用矩阵乘法解决的经典题目》from Matrix67
- 算法导论-矩阵乘法-strassen算法
- 学习心得:《十个利用矩阵乘法解决…
- 算法导论之四矩阵乘法的Strassen算法
- 《算法导论》学习心得（六）—— 计数排序（Java）
- 《算法导论》学习心得（七）—— 基数排序
- 第四章 分治策略 4.2 矩阵乘法的Strassen算法
- 算法导论-25.1-最短路径与矩阵乘法
- Dijkstra算法——《算法导论》学习心得（十三）
- 《算法导论》学习心得（五）—— 快排（Java）
- 算法导论第15章习题15.3-3最大矩阵链乘法
- 基于hadoop的矩阵乘法(学习笔记)
- 算法导论--------------Strassen矩阵乘法
- 二叉搜索树——《算法导论》学习心得（十二）
- 《算法导论》学习心得（八）—— 桶排序（JAVA）
- 《算法导论》之堆排序学习心得
- STRASSEN算法(矩阵乘法)
- strassen算法优化矩阵乘法