分治策略

最新推荐文章于 2023-06-19 09:26:37 发布
最新推荐文章于 2023-06-19 09:26:37 发布
阅读量551 收藏
点赞数 1
分类专栏： 数据结构和算法 文章标签： 算法

最大子数组

#include<iostream>
#include<climits>
using namespace std;

int getMiddle(int a[], int low, int mid, int high);
int maxSubset(int a[], int low, int high);
int main()
{
	int a[] = { 13, -3, -25, 20, -3, -16, -23, 18, 20, -7, 12, -5, -22, 15, -4, 7 };
	cout << "the maxsubset:" << maxSubset(a, 0, 15) << endl;
	system("pause");
}
int getMiddle(int a[], int low, int mid, int high)
{
	int left_max = INT_MIN;
	int right_max = INT_MIN;
	int sum = 0;
	for (int i = mid; i >= low; i--)//计算左边的最大和
	{
		sum += a[i];
		if (sum > left_max) left_max = sum;
	}
	sum = 0;
	for (int i = mid + 1; i <= high; i++)//计算右边的最大和
	{
		sum += a[i];
		if (sum > right_max) right_max = sum;
	}
	return right_max + left_max;
}

int maxSubset(int a[], int low,int high)
{
	if (low == high)
		return a[low];
	else
	{
		int mid = (low + high) / 2;
		int left = maxSubset(a, 0, mid);//最大和在左边，递归调用
		int right = maxSubset(a, mid + 1, high);//最大和在右边，递归调用
		int middle = getMiddle(a, low,mid, high);//最大和在中间
		if (middle > left&&middle > right) return middle;
		else if (left > middle&&left > right) return left;
		else return right;
	}
}

Strassen方法矩阵乘法

对于矩阵乘法 C = A × B，通常的做法是将矩阵进行分块相乘，如下图所示：


从上图可以看出这种分块相乘总共用了8次乘法，当然对于子矩阵相乘（如A0×B0），还可以继续递归使用分块相乘。对于中小矩阵来说，很适合使用这种分块乘法，但是对于大矩阵来说，递归的次数较多，如果能减少每次分块乘法的次数，那么性能将可以得到很好的提高。

Strassen矩阵乘法就是采用了一个简单的运算技巧，将上面的8次矩阵相乘变成了7次乘法，看别小看这减少的1次乘法，因为每递归1次，性能就提高了1/8，比如对于1024*1024的矩阵，第1次先分解成7次512*512的矩阵相乘，对于512*512的矩阵，又可以继续递归分解成256*256的矩阵相乘，…，一直递归下去，假设分解到64*64的矩阵大小后就不再递归，那么所花的时间将是分块矩阵乘法的(7/8) * (7/8) * (7/8) * (7/8) = 0.586倍，提高了快接近一倍。当然这是理论上的值，因为实际上strassen乘法增加了其他运算开销，实际性能会略低一点。

由上可见，Strassen矩阵乘法是通过递归实现的，它将一般情况下二阶矩阵乘法（可扩展到n阶，但Strassen矩阵乘法要求n是2的幂）所需的8次乘法降低为7次，其C++实现代码如下：

下面就是Strassen矩阵乘法的实现方法，

    M1 = (A0 + A3) × (B0 + B3)

   M2 = (A2 + A3) × B0

    M3 = A0 × (B1 - B3)

    M4 = A3 × (B2 - B0)

    M5 = (A0 + A1) × B3

    M6 = (A2 - A0) × (B0 + B1)

    M7 = (A1 - A3) × (B2 + B3)

    C0 = M1 + M4 - M5 + M7

    C1 = M3 + M5

    C2 = M2 + M4

    C3 = M1 - M2 + M3 + M6

在求解M1,M2,M3,M4,M5,M6,M7时需要使用7次矩阵乘法，其他都是矩阵加法和减法。

下面看看Strassen矩阵乘法的串行实现伪代码：

Serial_StrassenMultiply(A, B, C)

{

    T1 = A0 + A3;

    T2 = B0 + B3;

    StrassenMultiply(T1, T2, M1);

    T1 = A2 + A3;

    StrassenMultiply(T1, B0, M2);

    T1 = (B1 - B3);

    StrassenMultiply(A0, T1, M3);

 

    T1 = B2 - B0;

    StrassenMultiply(A3, T1, M4);

 

   T1 = A0 + A1;

   StrassenMultiply(T1, B3, M5);       

   

    T1 = A2 – A0;

    T2 = B0 + B1;

    StrassenMultiply(T1, T2, M6);

    T1 = A1 – A3;

    T2 = B2 + B3;

    StrassenMultiply(T1, T2, M7);

    C0 = M1 + M4 - M5 + M7

    C1 = M3 + M5

    C2 = M2 + M4

    C3 = M1 - M2 + M3 + M6

}

#include <iostream>  

using namespace std;

const int N = 6;     //Define the size of the Matrix  

template<typename T>
void Strassen(int n, T A[][N], T B[][N], T C[][N]);

template<typename T>
void input(int n, T p[][N]);

template<typename T>
void output(int n, T C[][N]);

int main() {
	//Define three Matrices  
	int A[N][N], B[N][N], C[N][N];

	//对A和B矩阵赋值，随便赋值都可以，测试用  
	for (int i = 0; i<N; i++) {
		for (int j = 0; j<N; j++) {
			A[i][j] = i * j;
			B[i][j] = i * j;
		}
	}

	//调用Strassen方法实现C=A*B  
	Strassen(N, A, B, C);

	//输出矩阵C中值  
	output(N, C);

	system("pause");
	return 0;
}


template<typename T>
void input(int n, T p[][N]) {
	for (int i = 0; i<n; i++) {
		cout << "Please Input Line " << i + 1 << endl;
		for (int j = 0; j<n; j++) {
			cin >> p[i][j];
		}
	}
}


template<typename T>
void output(int n, T C[][N]) {
	cout << "The Output Matrix is :" << endl;
	for (int i = 0; i<n; i++) {
		for (int j = 0; j<n; j++) {
			cout << C[i][j] << "" << endl;
		}
	}
}


template<typename T>
void Matrix_Multiply(T A[][N], T B[][N], T C[][N]) {  //Calculating A*B->C  
	for (int i = 0; i<2; i++) {
		for (int j = 0; j<2; j++) {
			C[i][j] = 0;
			for (int t = 0; t<2; t++) {
				C[i][j] = C[i][j] + A[i][t] * B[t][j];
			}
		}
	}
}


template <typename T>
void Matrix_Add(int n, T X[][N], T Y[][N], T Z[][N]) {
	for (int i = 0; i<n; i++) {
		for (int j = 0; j<n; j++) {
			Z[i][j] = X[i][j] + Y[i][j];
		}
	}
}


template <typename T>
void Matrix_Sub(int n, T X[][N], T Y[][N], T Z[][N]) {
	for (int i = 0; i<n; i++) {
		for (int j = 0; j<n; j++) {
			Z[i][j] = X[i][j] - Y[i][j];
		}
	}
}



template <typename T>
void Strassen(int n, T A[][N], T B[][N], T C[][N]) {
	T A11[N][N], A12[N][N], A21[N][N], A22[N][N];
	T B11[N][N], B12[N][N], B21[N][N], B22[N][N];
	T C11[N][N], C12[N][N], C21[N][N], C22[N][N];
	T M1[N][N], M2[N][N], M3[N][N], M4[N][N], M5[N][N], M6[N][N], M7[N][N];
	T AA[N][N], BB[N][N];

	if (n == 2) {  //2-order  
		Matrix_Multiply(A, B, C);
	}
	else {
		//将矩阵A和B分成阶数相同的四个子矩阵，即分治思想。  
		for (int i = 0; i<n / 2; i++) {
			for (int j = 0; j<n / 2; j++) {
				A11[i][j] = A[i][j];
				A12[i][j] = A[i][j + n / 2];
				A21[i][j] = A[i + n / 2][j];
				A22[i][j] = A[i + n / 2][j + n / 2];

				B11[i][j] = B[i][j];
				B12[i][j] = B[i][j + n / 2];
				B21[i][j] = B[i + n / 2][j];
				B22[i][j] = B[i + n / 2][j + n / 2];
			}
		}

		//Calculate M1 = (A0 + A3) × (B0 + B3)  
		Matrix_Add(n / 2, A11, A22, AA);
		Matrix_Add(n / 2, B11, B22, BB);
		Strassen(n / 2, AA, BB, M1);

		//Calculate M2 = (A2 + A3) × B0  
		Matrix_Add(n / 2, A21, A22, AA);
		Strassen(n / 2, AA, B11, M2);

		//Calculate M3 = A0 × (B1 - B3)  
		Matrix_Sub(n / 2, B12, B22, BB);
		Strassen(n / 2, A11, BB, M3);

		//Calculate M4 = A3 × (B2 - B0)  
		Matrix_Sub(n / 2, B21, B11, BB);
		Strassen(n / 2, A22, BB, M4);

		//Calculate M5 = (A0 + A1) × B3  
		Matrix_Add(n / 2, A11, A12, AA);
		Strassen(n / 2, AA, B22, M5);

		//Calculate M6 = (A2 - A0) × (B0 + B1)  
		Matrix_Sub(n / 2, A21, A11, AA);
		Matrix_Add(n / 2, B11, B12, BB);
		Strassen(n / 2, AA, BB, M6);

		//Calculate M7 = (A1 - A3) × (B2 + B3)  
		Matrix_Sub(n / 2, A12, A22, AA);
		Matrix_Add(n / 2, B21, B22, BB);
		Strassen(n / 2, AA, BB, M7);

		//Calculate C0 = M1 + M4 - M5 + M7  
		Matrix_Add(n / 2, M1, M4, AA);
		Matrix_Sub(n / 2, M7, M5, BB);
		Matrix_Add(n / 2, AA, BB, C11);

		//Calculate C1 = M3 + M5  
		Matrix_Add(n / 2, M3, M5, C12);

		//Calculate C2 = M2 + M4  
		Matrix_Add(n / 2, M2, M4, C21);

		//Calculate C3 = M1 - M2 + M3 + M6  
		Matrix_Sub(n / 2, M1, M2, AA);
		Matrix_Add(n / 2, M3, M6, BB);
		Matrix_Add(n / 2, AA, BB, C22);

		//Set the result to C[][N]  
		for (int i = 0; i<n / 2; i++) {
			for (int j = 0; j<n / 2; j++) {
				C[i][j] = C11[i][j];
				C[i][j + n / 2] = C12[i][j];
				C[i + n / 2][j] = C21[i][j];
				C[i + n / 2][j + n / 2] = C22[i][j];
			}
		}
	}
}


XILEO
关注
专栏目录
矩阵乘法-strassen算法
严霜九月
08-20 5330
 1.矩阵相乘的朴素算法 时间复杂度T(n)=Θ(n3)，朴素矩阵相乘算法，思想明了，编程实现简单。时间复杂度是Θ(n^3)。伪码如下 for i ← 1 to n     do for j ← 1 to n        do c[i][j] ← 0           for k ← 1 to n              do  c[i][j] ← c[i][j] + a[i][...
Strassen矩阵算法分析及其实现
镜花水月
12-11 784
对于矩阵乘法  C =  A × B，通常的做法是将矩阵进行分块相乘，如下图所示： 从上图可以看出这种分块相乘总共用了8次乘法，当然对于子矩阵相乘（如A0×B0），还可以继续递归使用分块相乘。对于中小矩阵来说，很适合使用这种分块乘法，但是对于大矩阵来说，递归的次数较多，如果能减少每次分块乘法的次数，那么性能将可以得到很好的提高。 Strassen矩阵乘法就是采用了一个简单的运算技巧，将上面...
矩阵乘法的strassen算法(C++实现)
04-23
一般情况下矩阵乘法需要三个for循环，时间复杂度为O(n^3)，现在我们将矩阵分块如图：( 来自MIT算法导论 ) 一般算法需要八次乘法 r = a * e + b * g ; s = a * f + b * h ; t = c * e + d * g; u = c * f + d * h; strassen将其变成7次乘法，因为大家都知道乘法比加减法消耗更多，所有时间复杂更高！ strassen的处理是： 令： p1 = a * ( f - h ) p2 = ( a + b ) * h p3 = ( c +d ) * e p4 = d * ( g - e ) p5 = ( a + d ) * ( e + h ) p6 = ( b - d ) * ( g + h ) p7 = ( a - c ) * ( e + f ) 那么我们可以知道： r = p5 + p4 + p6 - p2 s = p1 + p2 t = p3 + p4 u = p5 + p1 - p3 - p7
Strassen矩阵算法的实现
hello_bravo_的博客
05-30 634
仅仅针对2的幂次数阶的矩阵，时间复杂度O(n^lg7)#include <iostream>using namespace std; void gerResultStrassen(int **arr, int **brr, int n, int **crr) { if (n == 1) { crr[0][0] += arr[0][0] * brr[0][0];
strassen矩阵相乘算法(c++版）
09-27
strassen矩阵相乘算法c++代码，可以计算算法速度。
Strassen 算法 C++ 实现 任意矩阵相乘
11-18
Strassen 算法 C++ 实现 任意矩阵相乘 用Command line 输入编制好的两个矩阵，输出相乘的结果矩阵。如果需要手动输入，删除程序里的相关语句，添加输入命令即可。
Strassen矩阵相乘算法，C++实现，可运行
11-04
算法作业题目，用Strassen算法求矩阵相乘问题，C++源代码，可运行
n阶方阵乘法straseen
weixin_30287169的博客
05-03 783
原理：分块矩阵乘法，进行8次矩阵乘法，时间复杂度为 $\theta(n^3) = \theta(n^{\lg{8}}) $ , 改进后仅需要7次乘法, 时间复杂度为 \(\theta(n^{\lg{7}})\) 具体推到见算法导论中利用主定理推导时间复杂度 def matrix_divide(A): rows = len(A) mid = rows // 2 A11 = [...
Strassen：一种高效的矩阵相乘算法
weixin_40982849的博客
11-15 3232
Q1：如何提高矩阵相乘效率？ 矩阵乘法是种极其耗时的运算。 以C = A • B为例，其中A和B都是 n x n 的方阵。根据矩阵乘法的定义，计算过程如下： A1: 简单分治法 前提：假定A,B都是n等于2的次幂的方阵 基本思路：计算C=A*B时，将C,A,B矩阵进行分块操作，对每个分块的矩阵进行乘法运 算，运算完毕后重新对得到的C11,C12,C21,C22进行组合操作。 确定递归终止条件：当分块矩阵得到的阶数为1 时，得到的C即是A和B中两个元素的乘积。 每个公式需要计算两次矩阵乘法和一次矩阵加法，
《算法导论》第四章-矩阵乘法的Strassen算法（含C++代码）
Toby的博客
07-26 2533
本文为《算法导论》第四章-4.2-矩阵乘法的Strassen方法笔记，欢迎大家参考。
《算法设计与分析》实验报告：实验一（分治策略）
11-17
实验报告的标题是“《算法设计与分析》实验报告：实验一（分治策略）”，主要探讨了如何运用分治思想来设计和实现算法，并通过实际的编程实验进行了验证和性能分析。实验涉及的主要算法包括二分搜索、合并排序以及可...
mpi实现矩阵乘法，卷积，池化（gemm,covn,pooling）
最新发布
weixin_56273009的博客
06-19 999
【代码】mpi实现矩阵乘法，卷积，池化（gemm,covn,pooling）
详解矩阵乘法中的Strassen算法
u011250186的博客
07-29 8516
机器学习中需要训练大量数据，涉及大量复杂运算，例如卷积、矩阵等。这些复杂运算不仅多，而且每次计算的数据量很大，如果能针对这些运算进行优化，可以大幅提高性能。 一、矩阵乘法 如下图所示： Figure 1 Matrix Multiplication 二、Strassen算法 Figure 2 x^3 vs. x^2.807 三、Strassen原理详解 Strassen算法正是从这个角度出发，实现了降低算法复杂度！ 实现步骤可以分为以下4步： 3.1 S...
[算法]用C++实现Strassen方法求矩阵乘法（详细思路+代码+注释+测试）
Rover95的博客
06-15 3524
记录算法分析作业 学完《数据结构与算法分析（C++版）》（第三版）16.3.3节Strassen矩阵相乘的算法流程后，用C++实现Strassen方法求矩阵乘法 参考了这个博客的思路添加链接描述 Strassen矩阵相乘的算法，相比起普通算法，只是少了一次乘法，时间复杂度却少很多。由此可见，一个细小的差别说不定就会导致后果差别很大呀。（跑题~~ 以下是实现过程 1. 实现矩阵加法功能 //矩阵加法 void Matrix_Sum(int n, int** MatrixA, int** MatrixB, in
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值