分治策略（归并排序，二分查找，x的n次方，斐波那契(Fibonacci)数列，斯特拉森(Strassen)矩阵乘法）

最新推荐文章于 2024-06-25 16:39:42 发布
最新推荐文章于 2024-06-25 16:39:42 发布
阅读量1.3k 收藏 4
点赞数
分类专栏： 分治法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013351484/article/details/44043815
版权

   权当笔记！


（一）归并排序：

#include <stdio.h>
#include <stdlib.h>
#include <string>
typedef long long LL;
using namespace std;

/* T(n) = 2T(n/2) + ⊙(n) = nlog(n) */
void Merge_sort(int *A,int x,int y,int *t) /* x表示左闭，y表示右开 */
{  
    if(y - x > 1){  
        int m = x + (y - x) / 2;  
        int p = x,q = m,i = x;  
        Merge_sort(A, x, m, t);  
        Merge_sort(A, m, y, t);  
        while(p < m || q < y){  
            if(q >= y || (p < m && A[p] <= A[q]))
                t[i++] = A[p++];  
            else t[i++] = A[q++];  
        }  
        for(i=x; i<y; i++)
            A[i] = t[i];  
    }  
}  

int main()
{
	int t[15];
	int s[] = {4, 1, 7, 6, 3, 8, 2, 5, 0, 9};
	Merge_sort(s, 0, 10, t);
	int i;
	for(i=0; i<10; i++)
		printf("%d ", s[i]);
	printf("\n");
	return 0;
}


（二）二分查找：

用递归体会一下其中的分治思想，当然也可以用while循环解决！

#include <stdio.h>
#include <stdlib.h>
#include <string>
typedef long long LL;
using namespace std;

/* T(n) = T(n/2) + ⊙(1) = log(n) */

int Binary_find(int key, int left, int right, int *a)
{
	int mid = left + (right - left) / 2;
	if(a[mid] == key) return mid;
	else if(a[mid] > key) return Binary_find(key, left, mid - 1, a);
	else if(a[mid] < key) return Binary_find(key, mid + 1, right, a);
}

int main()
{
	int a[] = {1, 3, 4, 6, 7, 9, 12, 14, 23, 24};
	int i;
	int ans;
	for(i=0; i<8; i++){
		ans = Binary_find(a[i], 0, 7, a);
		printf("%d\n", ans);
	}
	return 0;
}

（三）x的n次方：

库函数<math.h>里面的double pow(double x, double y) 更加完美，指数可以是浮点型。这里手写个double Pow(double x, int n)。

#include <stdio.h>
#include <stdlib.h>
#include <string>
typedef long long LL;
using namespace std;

/* T(n) = T(n/2) + ⊙(1) = log(n) */

double f(double x, int n)
{
	if(1 == n) return x;
	int mid = (n>>1);
	double s = f(x, mid);
	if(n & 1) return s * s * x;
	else return s * s;
}

double Pow(double x, int n)
{
	if(0 == x && n > 0) return 0.0;
	else if(0 == n) return 1.0;
	else if(n > 0) return f(x, n);
	else if(n < 0) return (1/f(x, -n));
}

int main()
{
	double x;
	int n;
	while(~scanf("%lf%d", &x, &n)){
		printf("%0.6lf\n", Pow(x, n));
		printf("%0.6lf\n", pow(x, n));
	}
}

（四）斐波那契(Fibonacci)数列：

递归是最愚蠢的做法，迭代可以是 ⊙(n) 的复杂度，矩阵快速幂可达到 ⊙(log(n)) 的复杂度。

F(n) 表示第n个斐波那契数则有这样的关系：

矩阵   F(N+1)  F(N)          =        矩阵    1     1    的 N 次方

           F(N)       F(N-1)                            1      0

可用数学归纳法证明。所以结果就是普通的矩阵快速幂。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <iostream>
using namespace std;

int cnt;

/* 时间复杂度为指数级 */
LL Fibonacci(int n)
{
	cnt++;
	if(1 == n || 2 == n) return 1;
	else return Fibonacci(n - 1) + Fibonacci(n - 2);
}

/* T(n) = ⊙(n) */
LL Fibonacci1(int n)
{
	LL a[100000];
	a[1] = a[2] = 1;
	int i;
	for(i=3; i<=n; i++)
		a[i] = a[i - 1] + a[i - 2];
	return a[n];
}

typedef struct
{
    LL a[2][2];
}Matrix;

Matrix A, B;

Matrix Matrix_mul(Matrix X, Matrix Y)  
{  
    Matrix tmp;  
    memset(tmp.a, 0, sizeof(tmp));  
    int i,j,k;  
    for(i=0; i<2; i++)  
        for(j=0; j<2; j++)  
            for(k=0; k<2; k++)
                tmp.a[i][j] += X.a[i][k] * Y.a[k][j];  
    return tmp;  
}  

/* T(n) = ⊙(logn) */
LL Fibonacci2(int n)
{
	A.a[0][0] = 1;
	A.a[0][1] = 1;
	A.a[1][0] = 1;
	A.a[1][1] = 0;
	B.a[0][0] = 1;
	B.a[0][1] = 0;
	B.a[1][0] = 0;
	B.a[1][1] = 1;
	while(n)
	{
		if(n & 1) B = Matrix_mul(B, A);
		A = Matrix_mul(A, A);
		n >>= 1;
	}
	return B.a[0][0];
}

int main()
{
	int i;
	int text = 4;
	LL ans = Fibonacci1(text);
	//long begtime = clock();
	FILETIME beg,end;  
    GetSystemTimeAsFileTime(&beg);  
	for(i=0; i<100000; i++)
		Fibonacci2(text);
    GetSystemTimeAsFileTime(&end);
    long time = (end.dwLowDateTime-beg.dwLowDateTime);  
	//long endtime = clock();
    //cout<<endtime - begtime<<endl;  
	cout << time <<endl;
	cout << ans <<endl;
}

（五）斯特拉森(Strassen)矩阵乘法：

参考了网上的做法，重写了此矩阵乘法，用了一个4阶矩阵验证。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <iostream>
typedef long long LL;
using namespace std;

typedef int INT;
#define N 4 

typedef struct matrix
{
	INT a[N][N];
	matrix()
	{
		memset(a, 0, sizeof(a));
	}
}Matrix;

void Matrix_mul(const Matrix A, const Matrix B, Matrix &C)
{
	memset(C.a, 0, sizeof(C.a));
	int i,j,k;
	for(i=0; i<2; i++)
		for(j=0; j<2; j++)
			for(k=0; k<2; k++)
				C.a[i][j] += A.a[i][k] * B.a[k][j];
}

void Matrix_add(const int n, const Matrix A, const Matrix B, Matrix &C)
{
	memset(C.a, 0, sizeof(C.a));
	int i,j;
	for(i=0; i<n; i++)
		for(j=0; j<n; j++)
			C.a[i][j] = A.a[i][j] + B.a[i][j];
}

void Matrix_sub(const int n, const Matrix A, const Matrix B, Matrix &C)
{
	memset(C.a, 0, sizeof(C.a));
	int i,j;
	for(i=0; i<n; i++)
		for(j=0; j<n; j++)
			C.a[i][j] = A.a[i][j] - B.a[i][j];
}

void Strassen(INT n, const Matrix A, const Matrix B, Matrix &C)
{
	Matrix A11, A12, A21, A22;
	Matrix B11, B12, B21, B22;
	Matrix C11, C12, C21, C22;
	Matrix M1, M2, M3, M4, M5, M6, M7;
	Matrix At, Bt, Mt, Mt1;

	if(2 == n) Matrix_mul(A, B, C);
	else{
		n /= 2;
		int i, j;
		for(i=0; i<n; i++)
			for(j=0; j<n; j++){
				A11.a[i][j] = A.a[i][j];
				A12.a[i][j] = A.a[i][j + n];
				A21.a[i][j] = A.a[i + n][j];
				A22.a[i][j] = A.a[i + n][j + n];
				B11.a[i][j] = B.a[i][j];
				B12.a[i][j] = B.a[i][j + n];
				B21.a[i][j] = B.a[i + n][j];
				B22.a[i][j] = B.a[i + n][j + n];
			}

		Matrix_sub(n, A12, A22, At);
		Matrix_add(n, B21, B22, Bt);
		Strassen(n, At, Bt, M1);

		Matrix_add(n, A11, A22, At);
		Matrix_add(n, B11, B22, Bt);
		Strassen(n, At, Bt, M2);

		Matrix_sub(n, A11, A21, At);
		Matrix_add(n, B11, B12, Bt);
		Strassen(n, At, Bt, M3);

		Matrix_add(n, A11, A12, At);
		Strassen(n, At, B22, M4);

		Matrix_sub(n, B12, B22, Bt);
		Strassen(n, A11, Bt, M5);

		Matrix_sub(n, B21, B11, Bt);
		Strassen(n, A22, Bt, M6);

		Matrix_add(n, A21, A22, At);
		Strassen(n, At, B11, M7);

		/* sub_C */
		Matrix_add(n, M6, M1, Mt);
		Matrix_add(n, Mt, M2, Mt1);
		Matrix_sub(n, Mt1, M4, C11);

		Matrix_add(n, M5, M4, C12);

		Matrix_add(n, M6, M7, C21);

		Matrix_sub(n, M5, M3, Mt);
		Matrix_add(n, Mt, M2, Mt1);
		Matrix_sub(n, Mt1, M7, C22);

		for(i=0; i<n; i++)
			for(j=0; j<n; j++){
				C.a[i][j] = C11.a[i][j];
				C.a[i][j + n] = C12.a[i][j];
				C.a[i + n][j] = C21.a[i][j];
				C.a[i + n][j + n] = C22.a[i][j];
			}
	}
}

int main()
{
	Matrix A, B, C;
	A.a[0][0] = 1;
	A.a[0][1] = 0;
	A.a[0][2] = 2;
	A.a[0][3] = 1;
	A.a[1][0] = 0;
	A.a[1][1] = 3;
	A.a[1][2] = 1;
	A.a[1][3] = 2;
	A.a[2][0] = 0;
	A.a[2][1] = 0;
	A.a[2][2] = 2;
	A.a[2][3] = 2;
	A.a[3][0] = 2;
	A.a[3][1] = 3;
	A.a[3][2] = 0;
	A.a[3][3] = 1;

	B.a[0][0] = 2;
	B.a[0][1] = 1;
	B.a[0][2] = 0;
	B.a[0][3] = 0;
	B.a[1][0] = 0;
	B.a[1][1] = 1;
	B.a[1][2] = 1;
	B.a[1][3] = 1;
	B.a[2][0] = 1;
	B.a[2][1] = 0;
	B.a[2][2] = 2;
	B.a[2][3] = 2;
	B.a[3][0] = 3;
	B.a[3][1] = 0;
	B.a[3][2] = 2;
	B.a[3][3] = 1;

	Strassen(N, A, B, C);

	int i,j;
	for(i=0; i<N; i++){
		for(j=0; j<N; j++)
			printf("%-4d", C.a[i][j]);
		printf("\n");
	}
	return 0;
}









午后红茶馆
关注
专栏目录
lintcode-分治-x的n次幂
lz1997的博客
09-28 792
x的n次幂 实现 pow(x,n) 注意事项 不用担心精度，当答案和标准输出差绝对值小于1e-3时都算正确 样例 Pow(2.1, 3) = 9.261 Pow(0, 1) = 0 Pow(1, 0) = 1
求第n个斐波那契数
Zhang_Ting0020的博客
04-18 473
首先介绍的用递归的方法求第n个斐波那契数，此种方法的优点是代码简单，但是计算比较大的斐波那契数时，效率很低。代码如下：#include  &lt;stdio.h&gt;int fib(int n){ if (n &lt;= 2) return 1; else return fib(n - 1) + fib(n - 2);}int main(){ int n = 0; int ret = 0; ...
【算法】设计一个算法，采用“分治策略”求x的n次方--java
lushixuan12345的博客
04-08 2058
【算法】设计一个算法，采用“分治策略”求x的n次方--java
分治法求x的n次方
levi2469的博客
10-06 2659
#include <stdio.h> int f(int x,int n) { if(n1) return x; else if(n%20) return f(x,n/2)f(x,n/2); else return xf(x,(n-1)/2)*f(x,(n-1)/2); } int main() { int n; int x; printf(“请输入x的值:”); scanf("%d",&x); printf(“请输入n的值:”); scanf("%d",&n); pr
分治策略-递归（1）-求一个数的N次方
天马行空，隐姓埋名
10-26 3026
int numN(int a,int n) { if(n == 1) return a; if(n%2 == 0) { return numN(a,n/2) * numN(a,n/2); } else { return numN(a,(n-1)/2) * numN(a,(n-1)/2) * a; } }
矩阵（斐波那契数列和Strassen矩阵）下的分治算法及其分治算法的改进（上）
qq_41926985的博客
04-14 1394
我昨天在想，应试教育真的会把知识学死吗。我认为这只是一个借口，教育本来就不是活的，如果我们不主动去思考，去应用。而只是一味的为了考试而去学习，当然会把知识学的没有用处。所以说不是应试教育把知识学死了，而是你把知识学死了。 《增广贤文》里面有一句老话是：师傅领进门，修行在个人。前辈将知识传给我们，我们是要在其上进行再提炼，发展到我们的当代生活中。所以才有我们现在的美好生活。文化这个东西是不断再传承的...
函数递归练习（斐波那契数列，二分查找）
12-21
这里我们主要关注两个经典的递归应用实例：斐波那契数列和二分查找。 1. **斐波那契数列**： 斐波那契数列是一个典型的递归问题，其中每个数是前两个数的和。描述中的代码展示了如何使用递归方法计算斐波那契数列...
分治策略详解：二分查找、快速排序与归并排序实例
- 二分查找：这是一种典型的分治策略应用，针对有序数组，通过不断将查找范围减半的方式，使得时间复杂度达到O(log2n)，大大提高了查找效率。 - 快速排序：快速排序也是基于分治策略，选择一个枢轴元素，将数组...
递归与分治：Strassen矩阵乘法定理与Fibonacci数列示例
Strassen矩阵乘法是一种利用递归和分治策略来加速矩阵乘法运算的高级算法，其主要针对的是n×n的大矩阵。传统的矩阵乘法算法的时间复杂度为O(n^3)，但Strassen通过创新的方法将其降低到了O(n^log2(7))，这意味着在...
linux多线程程序实验，用不同线程完成一个矩阵乘法，以及子进程计算斐波那契数列，父进程输出结果
05-07
本实验通过创建多个线程，分别用于执行矩阵乘法和计算斐波那契数列，展示了多线程在并发处理不同计算任务中的应用。 一、线程基础 线程是操作系统分配CPU时间的基本单元，一个进程中可以包含一个或多个线程。与进程...
矩阵乘法的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
斯特拉森算法
ToBeBest灬Engineer
12-05 3207
Strassen演算法是個計算矩陣乘法的演算法。 設A, B為域 F上的方矩陣。求兩者的積C。 （一般矩陣可以填0的方法計算令它成為矩陣。） 將A, B, C分成相等大小的方塊矩陣： 即 於是 引入新矩陣 可得： 其中M_{i,
斯特拉森(Strassen)算法
热门推荐
weixin_43736127的博客
12-21 1万+
斯特拉森算法简介 先套用一下百度百科： 功能快捷键 合理的创建标题，有助于目录的生成 如何改变文本的样式 C语言描述 #include <stdio.h> #include<malloc.h> int MUL( int** MatrixA, int** MatrixB, int** MatrixResult, int MatrixSize ); int SUB(int** MatrixA, int** MatrixB, int** MatrixResult, int MatrixS
斐波那契数列 矩阵乘法解法
Jay_fearless的博客
02-25 853
分析 令 Fn=[fn(第n项)fn+1(第n+1项)Sn(前n项和)]\begin{array}{ll} &F_{n}= &\begin{bmatrix} f_{n}(第n项) & f_{n+1}(第n+1项) & S_{n}(前n项和)\\ \end{bmatrix} \end{array}​Fn​=​[fn​(第n项)​fn+1​(第n+1项)​Sn​(前n项和)​]​ 则 Fn+1=[fn+1fn+2Sn+1]\begin{array}{ll}
优化的求第n个斐波那契数——动态规划引例
晴空
02-11 422
斐波那契数列若反复重复计算，会产生很多重复的计算，若将每次的计算结果使用dp数组储存起来，若计算过，则调用数组，返回结果，则会大大提高效率。 一个问题必须拥有重叠子问题，才能使用动态规划去解决。 这个例子可以看出计算效率上的差异还是蛮大的： 代码： #include <stdio.h> #include <string.h> using namespace std; in...
分治算法详解
奋斗才是年轻该有的状态
08-20 1223
一、分治算法的基本思想   当我们求解某些问题时，由于这些问题要处理的数据相当多，或求解过程相当复杂，使得直接求解法在时间上相当长，或者根本无法直接求出。对于这类问题，我们往往先把它分解成几个子问题，找到求出这几个子问题的解法后，再找到合适的方法，把它们组合成求整个问题的解法。如果这些子问题还较大，难以解决，可以再把它们分成几个更小的子问题，以此类推，直至可以直接求出解为止。这就是分治策略的基本思
斯特拉森矩阵乘法
aa663325的博客
10-04 2255
先上代码package Sort; public class Matrix { public static void main(String[] args) { int[][] cc={{1,1,1,1,1,1,1,1},{1,1,1,1,1,1,1,1},{1,1,1,1,1,1,1,1},{1,1,1,1,1,1,1,1},{1,1,1,1,1,1,1,1},{1,1,1,1,1,1,
矩阵相乘算法及斯特拉森算法
m0_51499597的博客
10-08 448
先挖坑，再填坑~ 一、实验要求 二、朴素方法的代码部分 #include<iostream> using namespace std; #include<stdio.h> #include<math.h> int a[1000][1000],b[1000][1000]; int out[1000][1000]; int main() { int i,j,k,t; int n,m; scanf("%d %d",&n,&m);
（超简单、超易懂、超详细）算法精讲(四十三)：施特拉森矩阵乘法
最新发布
Malex2024的博客
06-25 639
施特拉森矩阵乘法是一种用于计算两个矩阵乘积的算法。它通过将原始矩阵划分为四个子矩阵，并使用递归的方式计算乘积。施特拉森矩阵乘法算法的基本思想是将矩阵乘法问题转化为更小规模的子问题，并利用这些子问题的解来计算原始问题的解。具体来说，施特拉森矩阵乘法算法的步骤如下：将两个待乘矩阵 A 和 B 分别划分为四个子矩阵 A11、A12、A21 和 A22，以及 B11、B12、B21 和 B22。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值