算法导论学习笔记—Strassen算法的Java实现

最新推荐文章于 2021-12-19 22:02:29 发布
最新推荐文章于 2021-12-19 22:02:29 发布
阅读量368 收藏
点赞数
分类专栏： 算法导论学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29864971/article/details/78666713
版权

Strassen算法

    Strassen算法的核心思想是令递归树稍微不那么茂盛，相比于简单的“分而治之”的矩阵递归计算，其递归的分支由8条减少到7条。其时间复杂度为O(n的lg7次方)。虽然，它的算法中需要新增10个(n/2 * n/2)的中间矩阵S1-S10。每次子矩阵的加减运算会增加O(n平方/4)的时间消耗，所以代码在执行S1-S10时，这部分的时间复杂度为10*O(n平方/4)，但是相比之下，Strassen算法减少了一次递归，所以时间复杂度上会减少。

   下面来看简单“分而治之”矩阵乘法和Strassen算法的对比：

(1) 简单“分而治之”矩阵乘法

package com.oracle.ThirdCharpter;
/**
 * 写一个简单的“分而治之的矩阵乘法”，即A = [A11 A12    B=[B11 B12   C=[A11*B11+A12*B21  A11*B12+A12*B22
 *                                        A21 A22]      B21 B22]     A21*B11+A22*B21  A21*B12+A22*B22]
 * 经过算法分析发现，其时间复杂度依然还是O(n的3次方)
 * @author zhegao
 *
 */
public class Practice1_4 {
    public int[][] matrix_multiply(int[][] a,int[][] b) {        
        if(a.length==1) {
            return new int[][] {{a[0][0]*b[0][0]}};
        }else {
            int[][] A11 = partition(a,1);
            int[][] B11 = partition(b,1);
            int[][] A12 = partition(a,2);
            int[][] B12 = partition(b,2);
            int[][] A21 = partition(a,3);
            int[][] B21 = partition(b,3);
            int[][] A22 = partition(a,4);
            int[][] B22 = partition(b,4);

            //进行加法运算
            int[][] C11 = matrixAdd(matrix_multiply(A11,B11),matrix_multiply(A12,B21));
            int[][] C12 = matrixAdd(matrix_multiply(A11,B12),matrix_multiply(A12,B22));
            int[][] C21 = matrixAdd(matrix_multiply(A21,B11),matrix_multiply(A22,B21));
            int[][] C22 = matrixAdd(matrix_multiply(A21,B12),matrix_multiply(A22,B22));
            int[][] C = merge(C11,C12,C21,C22);
            return C;
        }
        
    }
    //拆分矩阵，得到四个子矩阵，把不同位置的子矩阵标记成1，2，3，4。1——左上；2——右上；3——左下；4——右下
    public int[][] partition(int[][] arr,int index) {
        int len = arr.length;
        int[][] result = new int[len/2][len/2];
        switch(index) {
        case 1:
            for(int i=0;i<len/2;i++) {
                for(int j=0;j<len/2;j++) {                    
                    result[i][j]=arr[i][j];        
                    //System.out.println(result[i][j]);
                }
            };
            break;

        case 2:
            for(int i=0;i<len/2;i++) {
                for(int j=len/2;j<len;j++) {                
                    result[i][j-len/2]=arr[i][j];                        
                }
            };
            break;
        case 3:
            for(int i=len/2;i<len;i++) {                
                for(int j=0;j<len/2;j++) {                                    
                    result[i-len/2][j] = arr[i][j];
                }


            };
            break;
        case 4:
            for(int i=len/2;i<len;i++) {
                for(int j=len/2;j<len;j++) {                    
                    result[i-len/2][j-len/2]=arr[i][j];
                }
            };
        }
        return result;
    }
    //矩阵的加运算
    public int[][] matrixAdd(int[][] a,int[][] b){
        int[][] result = new int[a.length][a.length];
        for(int i=0;i<a.length;i++) {
            for(int j=0;j<a.length;j++) {
                result[i][j]=a[i][j]+b[i][j];
            }
        }
        return result;
    }
    public  void display(int[][] arr) {
        System.out.print("[");
        for(int i=0;i<arr.length;i++) {
            for(int j=0;j<arr.length;j++) {
                if(j==arr.length-1) {
                    System.out.print(arr[i][j]);
                }else {
                    System.out.print(arr[i][j]+ " ");
                }
            }
            System.out.print("]");
            System.out.print("\n");
        }    

    }

    //将四个子矩阵合并成一个整体的大矩阵
    public int[][] merge(int[][] a1,int[][] a2,int[][] a3,int[][] a4){
        int len = a1.length;
        int[][] result = new int[len*2][len*2];
        for(int i=0;i<result.length;i++) {
            if(i<len) {
                for(int j=0;j<result.length;j++) {
                    if(j<len) {
                        result[i][j]=a1[i][j];
                    }else {
                        result[i][j] = a2[i][j-len];
                    }
                }
            }else {
                for(int j=0;j<result.length;j++) {
                    if(j<len) {
                        result[i][j]=a3[i-len][j];
                    }else {
                        result[i][j] = a4[i-len][j-len];
                    }
                }
            }
        }
        return result;
    }
    public static void main(String[] args) {
        int[][] arr = new int[][] {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
        Practice1_4 prac = new Practice1_4();
        int[][] result1 = prac.partition(arr, 1);
        int[][] result2 = prac.partition(arr, 2);
        int[][] result3 = prac.partition(arr, 3);
        int[][] result4 = prac.partition(arr, 4);

      //测试矩阵分离方法

        prac.display(result1);
        prac.display(result2);
        prac.display(result3);
        prac.display(result4);
   
        //测试矩阵的合并方法
        int[][] merge = prac.merge(result1, result2, result3, result4);
        prac.display(merge);
        
        //测试分而治之的矩阵乘法
        int[][] a1 = new int[][] {{1,2,3,4},{4,3,2,1},{0,1,2,3},{3,2,1,0}};
        int[][] a2 = new int[][] {{1,2,3,4},{4,3,2,1},{0,1,2,3},{3,2,1,0}};
        prac.display(prac.matrix_multiply(a1, a2));
    }

}

(2)Strassen算法

package com.oracle.ThirdCharpter;

/**
 * 使用Strassen算法进行矩阵乘法
 * 相比于“分而治之”的矩阵乘法，Stassen算法的递归分支只有7条，所以其时间复杂度为O(log2 7)
 *
 * 分析：Strassen算法相比传统”分而治之“的算法，它的递归分支只有7条，P1-P7。
 * @author zhegao
 *
 */
public class Practice1_5 {

    public int[][] matrix_multiply(int[][] a,int[][] b) {        
        if(a.length==1) {
            return new int[][] {{a[0][0]*b[0][0]}};
        }else {
            int[][] A11 = partition(a,1);
            int[][] B11 = partition(b,1);
            int[][] A12 = partition(a,2);
            int[][] B12 = partition(b,2);
            int[][] A21 = partition(a,3);
            int[][] B21 = partition(b,3);
            int[][] A22 = partition(a,4);
            int[][] B22 = partition(b,4);
            
            //计算S1-S10的中间矩阵
            int[][] S1 = matrixSubstract(B12,B22);
            int[][] S2 = matrixAdd(A11,A12);
            int[][] S3 = matrixAdd(A21,A22);
            int[][] S4 = matrixSubstract(B21,B11);
            int[][] S5 = matrixAdd(A11,A22);
            int[][] S6 = matrixAdd(B11,B22);
            int[][] S7 = matrixSubstract(A12,A22);
            int[][] S8 = matrixAdd(B21,B22);
            int[][] S9 = matrixSubstract(A11,A21);
            int[][] S10 = matrixAdd(B11,B12);
            
            //计算P1-P7的几个递归矩阵
            int[][] P1 = matrix_multiply(A11,S1);
            int[][] P2 = matrix_multiply(S2,B22);
            int[][] P3 = matrix_multiply(S3,B11);
            int[][] P4 = matrix_multiply(A22,S4);
            int[][] P5 = matrix_multiply(S5,S6);
            int[][] P6 = matrix_multiply(S7,S8);
            int[][] P7 = matrix_multiply(S9,S10);
            
            //进行加减运算
            int[][] C11 = matrixAdd(matrixSubstract(matrixAdd(P5,P4),P2),P6);
            int[][] C12 = matrixAdd(P1,P2);
            int[][] C21 = matrixAdd(P3,P4);
            int[][] C22 = matrixSubstract(matrixSubstract(matrixAdd(P5,P1),P3),P7);
            
            //合并各个子矩阵
            int[][] C = merge(C11,C12,C21,C22);
            return C;
        }

    }

    //拆分矩阵，得到四个子矩阵，把不同位置的子矩阵标记成1，2，3，4。1——左上；2——右上；3——左下；4——右下
    public int[][] partition(int[][] arr,int index) {
        int len = arr.length;
        int[][] result = new int[len/2][len/2];
        switch(index) {
        case 1:
            for(int i=0;i<len/2;i++) {
                for(int j=0;j<len/2;j++) {                    
                    result[i][j]=arr[i][j];        
                    //System.out.println(result[i][j]);
                }
            };
            break;

        case 2:
            for(int i=0;i<len/2;i++) {
                for(int j=len/2;j<len;j++) {                
                    result[i][j-len/2]=arr[i][j];                        
                }
            };
            break;
        case 3:
            for(int i=len/2;i<len;i++) {                
                for(int j=0;j<len/2;j++) {                                    
                    result[i-len/2][j] = arr[i][j];
                }


            };
            break;
        case 4:
            for(int i=len/2;i<len;i++) {
                for(int j=len/2;j<len;j++) {                    
                    result[i-len/2][j-len/2]=arr[i][j];
                }
            };
        }
        return result;
    }
    
    //矩阵的加运算
    public int[][] matrixAdd(int[][] a,int[][] b){
        int[][] result = new int[a.length][a.length];
        for(int i=0;i<a.length;i++) {
            for(int j=0;j<a.length;j++) {
                result[i][j]=a[i][j]+b[i][j];
            }
        }
        return result;
    }
    
    //矩阵的减运算
    public int[][] matrixSubstract(int[][] a,int[][] b){
        int[][] result = new int[a.length][a.length];
        for(int i=0;i<a.length;i++) {
            for(int j=0;j<a.length;j++) {
                result[i][j]=a[i][j]-b[i][j];
            }
        }
        return result;
    }
    public  void display(int[][] arr) {
        System.out.print("[");
        for(int i=0;i<arr.length;i++) {
            for(int j=0;j<arr.length;j++) {
                if(j==arr.length-1) {
                    System.out.print(arr[i][j]);
                }else {
                    System.out.print(arr[i][j]+ " ");
                }
            }
            System.out.print("]");
            System.out.print("\n");
        }    
    }
    
    //将四个子矩阵合并成一个整体的大矩阵
        public int[][] merge(int[][] a1,int[][] a2,int[][] a3,int[][] a4){
            int len = a1.length;
            int[][] result = new int[len*2][len*2];
            for(int i=0;i<result.length;i++) {
                if(i<len) {
                    for(int j=0;j<result.length;j++) {
                        if(j<len) {
                            result[i][j]=a1[i][j];
                        }else {
                            result[i][j] = a2[i][j-len];
                        }
                    }
                }else {
                    for(int j=0;j<result.length;j++) {
                        if(j<len) {
                            result[i][j]=a3[i-len][j];
                        }else {
                            result[i][j] = a4[i-len][j-len];
                        }
                    }
                }
            }
            return result;
        }
    public static void main(String[] args) {
        //测试分而治之的矩阵乘法
        Practice1_5 prac = new Practice1_5();
        int[][] a1 = new int[][] {{1,2,3,4},{4,3,2,1},{0,1,2,3},{3,2,1,0}};
        int[][] a2 = new int[][] {{1,2,3,4},{4,3,2,1},{0,1,2,3},{3,2,1,0}};
        prac.display(prac.matrix_multiply(a1, a2));
    }

}


qq_29864971
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Strassen矩阵算法java实现
lss1007472173的专栏
04-19 1014
首先，我们还是需要假设n是2的幂。将矩阵A，B和C中每一矩阵都分块成为4个大小相等的子矩阵，每个子矩阵都是n/2×n/2的方阵。由此可将方程C=AB重写为:
算法学习笔记——递归算法
最新发布
qq_59575689的博客
03-23 207
递归思维是一种从下向上的思维方式，使用递归算法往往可以简化我们的代码，而且还帮我们解决了很复杂的问题。当你将问题不断缩小规模递去的时候，必须有一个明确的结束递去的临界点（递归出口），一旦达到这个临界点即就从该点原路返回到原点，最终问题得到解决。将递归问题分解为若干个规模较小，与原问题形式相同的子问题，这些子问题可以用相同的解题思路来解决。递归算法就是将原问题不断分解为规模缩小的子问题，然后递归调用方法来表示。（用同一个方法去解决规模不同的问题）（2）提取重复的逻辑，缩小问题的规模不断递去。
算法导论第4章strassen算法JAVA实现
u011250186的博客
07-29 457
今天看了strassen算法，用java实现了一下。 另外题目4.2-3，如何修改Strassen算法，使之适应矩阵规模n不是2的幂的情况？ 答：添加额外的行或列使之成为2的幂的方阵，添加的行或列均为0即可。 文章中提到在分解矩阵时使用复杂度为θ(1)的下标运算，本人为了方便，是采用拷贝赋值的方式进行的矩阵分解。 package answers.chapter04; import java.util.Arrays; public class MatrixMultiply ...
矩阵相乘Strassen算法Java实现
dawn_after_dark的博客
12-01 5587
前言我们都知道矩阵相乘的规则，矩阵1的m行与矩阵2的n列对应的位置的乘积之和即为结果矩阵m行n列的值，所以只有当矩阵1的列数等于矩阵2的行数时，才可以进行相乘。其实矩阵的本质是线性方程式的表示形式，比如： 好了，本篇博客重点不在这里。经典方法矩阵相乘的经典实现就是按照相乘规则来编写的，三重循环即可public static void mutipleMatrix(int[][] matrix
strassen算法java_使用java写的矩阵乘法实例（Strassen算法）_Java_软件编程
weixin_39830906的博客
02-27 204
Strassen算法于1969年由德国数学家Strassen提出，该方法引入七个中间变量，每个中间变量都只需要进行一次乘法运算。而朴素算法却需要进行8次乘法运算。原理Strassen算法的原理如下所示，使用sympy验证Strassen算法的正确性import sympy as sA = s.Symbol("A")B = s.Symbol("B")C = s.Symbol("C")D = s.Sy...
java实现任意矩阵Strassen算法
09-02
主要介绍了java实现任意矩阵Strassen算法的相关资料,需要的朋友可以参考下
用Java实现任意大小矩阵Strassen算法
02-04
详细情况见链接：http://www.oschina.net/code/snippet_2626980_53978
Strassen矩阵乘法
05-16
Strassen矩阵乘法，输入两个4X4的矩阵，对应得到相应结果
算法学习笔记 之回溯算法
诗酒年华
12-19 1187
回溯算法解N皇后问题
算法导论授课教案学习笔记
01-31
这份"算法导论授课教案学习笔记"是针对该书的深入学习资源，包括了教学教案、课后作业及解答，对于正在学习算法的学生来说，无疑是一份极其宝贵的参考资料。 教程部分可能涵盖以下知识点： 1. **算法基础**：介绍...
java实现strassen算法 运用了分治法和strassen原理
10-03
java实现strassen算法 运用了分治法和strassen原理 课堂作业
算法设计与分析实验 Strassen矩阵乘法 java实现
12-06
算法设计与分析实验，Strassen矩阵乘法，java实现，输入矩阵阶数后由系统自动生成两个矩阵，然后用Strassen方法，和普通方法分别计算乘法结果。
strassen算法实现
08-14
strassen将其变成7次乘法，因为大家都知道乘法比加减法消耗更多，所有时间复杂更高！ 可以看到上面只有7次乘法和多次加减法，最终达到降低复杂度为O( n^lg7 ) ~= O( n^2.81 );
Strassen矩阵连乘问题，Java实现
01-23
设计一个矩阵相乘的Strassen算法编程实现并做算法的时间复杂性分析。 其中：乘积矩阵C = A*B， A=（aij）n*n，B=（bij）n*n （1）考虑n为2的幂次方的情形，取n=8实现分治递归； （2）考虑n不是2的幂次方，n为偶数的情形，设计一个传统方法与的Strassen算法相结合的矩阵相乘算法,取n=12实现分治递归（可以有多种方案实现）； 矩阵A,B元素自动生成，限定矩阵元素在0-10之间。
算法导论试题及答案
06-10
在"算法导论试题及答案"这个压缩包中，我们可以推测包含了一些与该教材相关的学习资源，如： 1. **课程表.doc**：这可能是一个详细的课程计划，列出了整个学期的学习进度和教学内容，包括每个主题的讲解日期、重点...
算法导论答案
06-12
提供的压缩包文件“算法导论答案 - 副本”很可能包含了书中习题的解答和相关的学习笔记，这对于学习和理解书中的概念极其有帮助。 首先，我们要明白“算法”是解决问题或执行任务的精确步骤，它们是计算机科学的...
[麻省理工学院-算法导论].Introduction.to.Algorithms.-.Lecture.Notes 算法导论-课堂笔记 讲义
01-06
以上只是《算法导论》部分内容的概述，实际的课堂笔记和讲义会包含更丰富的例子、习题和解析，帮助读者深入理解和掌握这些概念。通过学习这些内容，可以提升对算法和数据结构的理解，为解决实际问题打下坚实基础。
算法导论读书笔记（整理别人的）
03-12
《算法导论》是计算机科学领域的一本经典著作，它深入浅出地介绍了各种重要的算法，并提供了详尽的分析和实现。这篇读书笔记主要涵盖了以下几个方面的重要知识点： 1. **算法基础**：算法是解决问题的步骤序列，是...
strassen矩阵乘法 java_java实现任意矩阵Strassen算法
weixin_39665762的博客
02-22 297
本例输入为两个任意尺寸的矩阵m * n, n * m，输出为两个矩阵的乘积。计算任意尺寸矩阵相乘时，使用了Strassen算法。程序为自编，经过测试，请放心使用。基本算法是：1.对于方阵(正方形矩阵)，找到最大的l, 使得l = 2 ^ k, k为整数并且l < m。边长为l的方形矩阵则采用Strassen算法，其余部分以及方形矩阵中遗漏的部分用蛮力法。2.对于非方阵，依照行列相应添加0使其...
算法导论笔记：伪代码、分治与概率分析
《算法导论笔记》是一份针对2019年面试准备的资料，主要聚焦于Thomas H. Cormen等作者编写的经典教材《算法导论》第三版。这份笔记详尽地涵盖了算法的基础概念，从伪代码的运用、算法的正确性证明及复杂度分析，到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值