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

最新推荐文章于 2022-04-08 18:43:51 发布
最新推荐文章于 2022-04-08 18:43:51 发布
阅读量1.2k 收藏 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 783
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 464
首先介绍的用递归的方法求第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 2014
【算法】设计一个算法，采用“分治策略”求x的n次方--java
分治法求x的n次方
levi2469的博客
10-06 2627
#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 2996
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; } }
函数递归练习（斐波那契数列，二分查找）
12-21
这里我们主要关注两个经典的递归应用实例：斐波那契数列和二分查找。 1. **斐波那契数列**： 斐波那契数列是一个典型的递归问题，其中每个数是前两个数的和。描述中的代码展示了如何使用递归方法计算斐波那契数列...
linux多线程程序实验，用不同线程完成一个矩阵乘法，以及子进程计算斐波那契数列，父进程输出结果
05-07
本实验通过创建多个线程，分别用于执行矩阵乘法和计算斐波那契数列，展示了多线程在并发处理不同计算任务中的应用。 一、线程基础 线程是操作系统分配CPU时间的基本单元，一个进程中可以包含一个或多个线程。与进程...
项目示例 1. 矩阵操作 2. 线性回归 3. 斐波那契数列 4. 排序算法 5. 数值积分 1. 矩阵操作 项目描述 创建一个
最新发布
09-14
3. 斐波那契数列 4. 排序算法 5. 数值积分 1. 矩阵操作 项目描述 创建一个 J 程序，用于实现矩阵的基本操作，如矩阵加法、矩阵乘法、转置等。 实现步骤 j 深色版本 1NB. 定义矩阵加法 2matrix_add=: + 3 4NB. 定义...
斐波那契数列Ⅱ【矩阵乘法】
//(^ o ^)//
12-12 744
>Link luogu P1962 >Description 快速求斐波那契数列的第NNN项 >解题思路 普通做法：模拟，O(n)O(n)O(n) 考虑矩阵乘法 如何构建矩阵： 由于斐波那契数列中 fn=fn−1+fn−2f_n=f_{n-1}+f_{n-2}fn​=fn−1​+fn−2​， 所以先设一个 1∗21*21∗2 矩阵 AAA 为 [1,1][1,1][1,1]，及 [f1,f2][f_1,f_2][f1​,f2​] 为了使 [f1,f2][f_1,f_2][f1​,f2​
斐波那契数列 优化矩阵求法实例
12-31
在做编程题目的时候经常会遇到“斐波那契数列”相关的题目，尤其在做OJ中。下面说一些方法： 　(一)递归 　递归是最慢的会发生重复计算，时间复杂度成指数级。 代码如下:long long fac(int n){　if(n==1) return 1;...
矩阵乘法的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 3194
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 833
分析 令 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 408
斐波那契数列若反复重复计算，会产生很多重复的计算，若将每次的计算结果使用dp数组储存起来，若计算过，则调用数组，返回结果，则会大大提高效率。 一个问题必须拥有重叠子问题，才能使用动态规划去解决。 这个例子可以看出计算效率上的差异还是蛮大的： 代码： #include <stdio.h> #include <string.h> using namespace std; in...
分治算法详解
奋斗才是年轻该有的状态
08-20 1202
一、分治算法的基本思想   当我们求解某些问题时，由于这些问题要处理的数据相当多，或求解过程相当复杂，使得直接求解法在时间上相当长，或者根本无法直接求出。对于这类问题，我们往往先把它分解成几个子问题，找到求出这几个子问题的解法后，再找到合适的方法，把它们组合成求整个问题的解法。如果这些子问题还较大，难以解决，可以再把它们分成几个更小的子问题，以此类推，直至可以直接求出解为止。这就是分治策略的基本思
斯特拉森矩阵乘法
aa663325的博客
10-04 2239
先上代码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 437
先挖坑，再填坑~ 一、实验要求 二、朴素方法的代码部分 #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);
求第n个Fibonaccid的值 并取模
hz18790581821的博客
04-11 1160
1. 传统的方法  递推公式  f[n]=f[n-1]+f[n-2] n>2 2. 运用矩阵乘法求解 #include using namespace std; const int N=2; const int mod=10000007; struct M{ long long int m[N][N]; }; M A= //需要根
分治策略详解：二分查找、快速排序与归并排序实例
- 二分查找：这是一种典型的分治策略应用，针对有序数组，通过不断将查找范围减半的方式，使得时间复杂度达到O(log2n)，大大提高了查找效率。 - 快速排序：快速排序也是基于分治策略，选择一个枢轴元素，将数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值