devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

计算机算法设计与分析（整理+代码）更新ing_算法设计与技巧分析csdn

作者：繁依Fanyi0 | 2024-07-27 16:58:10

赞

踩

算法设计与技巧分析csdn

一.递归与分治

1.大整数的乘法

将n位的整数分成两段，每段长度数 n/2

  1. package algorithm_2019;
  2. import java.math.BigInteger;
  3. import java.util.Scanner;
  4. public class 分治法求大整数乘法{
  5. 	static Scanner cin = new Scanner(System.in);
  6. 	
  7. 	static BigInteger Sign(BigInteger a) {//符号
  8. 		if(a.compareTo(BigInteger.ZERO) > 0)
  9. 			return BigInteger.ONE;
  10. 		else return BigInteger.valueOf(-1);
  11. 	}
  12.  
  13. 	static int Max(int a,int b) {//比较大小
  14. 		if(a>b) return a;
  15. 		else return b;
  16. 	}
  17.  
  18. 	static BigInteger multi(BigInteger a,BigInteger b,int len_a,int len_b) {
  19. 		BigInteger sign = Sign(a).multiply(Sign(b));
  20. 		a = a.abs();
  21. 		b = b.abs();
  22. 		if(a.compareTo(BigInteger.ZERO) == 0 || b.compareTo(BigInteger.ZERO) == 0)
  23. 			return BigInteger.ZERO;
  24. 		else if(len_a == 1 || len_b == 1)
  25. 			return sign.multiply(a.multiply(b));
  26. 		else {
  27. 			int half = Max(len_a,len_b) / 2;
  28. 			int lena = len_a - half;
  29. 			int lenb = len_b - half;
  30. 			 
  31. 			BigInteger tmp1 = BigInteger.valueOf(10).pow(half);
  32. 			BigInteger tmp2 = BigInteger.valueOf(10).pow(2*half);
  33. 			BigInteger A = a.divide(tmp1);
  34. 			BigInteger B = a.mod(tmp1);
  35. 			BigInteger C = b.divide(tmp1);
  36. 			BigInteger D = b.mod(tmp1);
  37. 			BigInteger AC = multi(A,C,lena,lenb);
  38. 			BigInteger BD = multi(B,D,half,half);
  39.  
  40. 			 
  41. 			BigInteger num1 = A.subtract(B);
  42. 			BigInteger num2 = D.subtract(C);
  43. 			int len1 = num1.abs().toString().length();
  44. 			int len2 = num2.abs().toString().length();
  45.  
  46. 			 
  47. 			BigInteger ABCD = multi(num1,num2,len1,len2).add(AC).add(BD);
  48. 			return sign.multiply(AC.multiply(tmp2).add(ABCD.multiply(tmp1)).add(BD));
  49. 		}
  50. 	}
  51.  
  52. 	public static void main(String[] args) {
  53. 		BigInteger a = cin.nextBigInteger();
  54. 		BigInteger b = cin.nextBigInteger();
  55. 		String str_a = a.toString();
  56. 		String str_b = b.toString();
  57. 		System.out.println("分治法求大整数乘法：\n"+multi(a,b,str_a.length(),str_b.length()));
  58. 	}
  59. }

2.Strassen矩阵乘法

3.棋盘覆盖

4.合并排序

递归的实现：

算法设计的思想就是，将一个大的序列划分成两个小的左右序列，然后这样递归下去，先完成小的序列的有序化，再将两个有序化的小的序列合并，完成大的序列的有序化。这里需要注意的就是在将两个有序的子数组有序的合并到一起的时候，可能某个子数组会有剩下的元素，没有被转移到新数组中，这里就需要在最后加上一个判断，来将两个子数组中可能剩下的元素都转移到新数组中

  1. void merge_sort(vector<int> &a,int l,int r){
  2. 	if(l>=r)
  3. 	    return;
  4. 	int mid=(l+r)/2;
  5. 	merge_sort(a,l,mid);
  6. 	merge_sort(a,mid+1,r);//左半部分和右半部分排序 
  7. 	static vector<int> w;
  8. 	w.clear(); 
  9. 	int i=l,j=mid+1;
  10. 	while(i<=mid&&j<=r){//将两个有序数组合并 
  11. 		if(a[i]<=a[j])
  12. 		    w.push_back(a[i++]);
  13. 		else
  14. 		    w.push_back(a[j++]);
  15. 	}
  16. 	while(i<=mid) w.push_back(a[i++]);//余下的部分添加到最后 
  17. 	while(j<=r) w.push_back(a[j++]);
  18. 	for(int i=l,j=0;j<w.size();i++,j++)//转移 
  19. 	    a[i]=w[j];
  20. }

非递归的实现：

归并排序的非递归的实现就是不将数组划分，而是直接先将数组a 中相邻元素两两配对，用合并算法将他们排序，构成n/2组长度为2的排好序的子数组段，再将他们排序成长度为4的排好序的子数组段，如此下去，直至整个数组排好序

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. template<typename T>
  5. void Merge(T a[], T p[], int l, int m, int r){
  6. 	int left = l, j = m + 1, k = l;
  7. 	while ((left <= m) && (j <= r)){
  8. 		if (a[left] <= a[j])
  9. 			p[k++] = a[left++];
  10. 		else
  11. 			p[k++] = a[j++];
  12. 	}
  13. 	if (left > m)
  14. 		for (int q = j; q <= r; q++)
  15. 			p[k++] = a[q];
  16. 	if (j > r)
  17. 		for (int q = left; q <= m; q++)
  18. 			p[k++] = a[q];
  19. }
  20.  
  21. template<typename T>
  22. void MergePass(T a[], T p[], int s, int b){
  23. 	int i = 0;
  24. 	while (i <= b - 2 * s){
  25. 		Merge(a,p,i,i+s-1,i+2*s-1);
  26. 		i = i + 2 * s;
  27. 	}
  28. 	if (i + s < b)
  29. 		Merge(a,p,i,i+s-1,b-1);
  30. 	else
  31. 		for (int q = i; q < b; q++)
  32. 			p[q] = a[q];
  33. }
  34.  
  35. template<typename T>
  36. void MergeSort(T a[], int b){
  37. 	T* p = new T[b];
  38. 	int s = 1;
  39. 	while (s < b){
  40. 		MergePass(a,p,s,b);
  41. 		s += s;
  42. 		MergePass(p,a,s,b);
  43. 		s += s;
  44. 	}
  45. }
  46.  
  47. int main(){
  48. 	int m;
  49. 	cin >> m;
  50. 	int* a = new int[m];
  51. 	for (int i = 0; i < m; i++)
  52. 		cin >> a[i];
  53. 	MergeSort(a, m);
  54. 	for (int i = 0; i < m; i++)
  55. 		cout << a[i] << ' ';
  56. 	cout<<endl;
  57. 	return 0;
  58. }

归并排序思想解决逆序对问题：

这里用到了归并的思想，你需要求出左边部分的逆序对数，然后求出右边部分的逆序对数，然后还要求出左半部分和右半部分汇总起来的时候的逆序对数，因为是和归并排序一样的实现，所以这个算法的时间复杂度是O(nlogn)。

需要注意的就是，在分别求出左边和右边的逆序对数的时候，还得再求出左右两部分的逆序对数量，因为这里是对数组进行从大到小的排序，当右半部分比左半部分的某个元素小的时候，它一定比左边元素后边的所有元素都小。

  1. int find(vector<int> &a,int l,int r){
  2. 	if(l>=r)
  3. 	    return 0;
  4. 	int res=0;
  5. 	int mid=(l+r)/2;
  6. 	res+=find(a,l,mid);//左 
  7. 	res+=find(a,mid+1,r);//右 
  8. 	static vector<int> w;
  9. 	w.clear(); 
  10. 	int i=l,j=mid+1;
  11. 	while(i<=mid&&j<=r){//交叉排序 
  12. 		if(a[i]<=a[j])
  13. 		    w.push_back(a[i++]);
  14. 		else{
  15. 			res+=mid-i+1;//!!! a[j] 比 a[i] 小的时候，一定也比后边的都小 
  16. 			w.push_back(a[j++]);
  17. 		}
  18. 	}
  19. 	while(i<=mid) w.push_back(a[i++]);//剩余部分 
  20. 	while(j<=r) w.push_back(a[j++]);
  21. 	for(int i=l,j=0;j<w.size();i++,j++)
  22. 	    a[i]=w[j];
  23. 	return res;
  24. }

5.快速排序

  1. def swap(a,b):
  2.     t=a
  3.     a=b
  4.     b=t
  5.     
  6. def QuickSort(a, l, r):
  7.     if l>r:
  8.         return -1
  9.     temp=a[l]
  10.     i=l
  11.     j=r
  12.     while i!=j:
  13.         while a[j]>=temp and i<j:
  14.             j-=1
  15.         while a[i]<=temp and i<j:
  16.             i+=1
  17.         if i<j:
  18.             swap(a[i],a[j])
  19.     a[l]=a[i]
  20.     a[i]=temp    
  21.     QuickSort(a,l,i-1)
  22.     QuickSort(a,i+1,r)
  23.  
  24.  
  25. a=input().strip().split()
  26. a=[int(i) for i in a]
  27. QuickSort(a,0,len(a)-1)
  28. print(a)

6.线性时间选择

7.最接近点对问题

8.循环赛日程表

  1. void GameTable(int k){
  2. 	int n=2;
  3. 	a[1][1]=1;
  4. 	a[1][2]=2;
  5. 	a[2][1]=2;
  6. 	a[2][2]=1;//预先把左上角设置好 
  7. 	for(int t=2;t<k;t++){
  8. 		int temp=n;//2^(k-1)
  9. 		n=n*2;
  10. 		for(int i=temp+1;i<=n;i++){//左下角 
  11. 			for(int j=1;j<=temp;j++){
  12. 				a[i][j]=a[i-temp][j]+temp;
  13. 			}
  14. 		}
  15. 		for(int i=1;i<=temp;i++){//右上角 
  16. 			for(int j=temp+1;j<=n;j++){
  17. 				a[i][j]=a[i+temp][j-temp];
  18. 			}
  19. 		}
  20. 		for(int i=temp+1;i<=n;i++){//右下角 
  21. 			for(int j=temp+1;j<=n;j++){
  22. 				a[i][j]=a[i-temp][j-temp];
  23. 			}
  24. 		}
  25. 	}
  26. }
  27. void Print(int k){//打印函数 
  28. 	int sum=1;
  29. 	for(int i=1;i<k;i++)
  30. 		sum*=2;
  31. 	for(int i=1;i<=sum;i++){
  32. 		for(int j=1;j<=sum;j++){
  33. 			cout<<a[i][j]<<" ";
  34. 		}
  35. 		cout<<endl;
  36. 	}
  37. }

分治法实现：

按分治策略，我们可以将所有的选手分为两半，则n个选手的比赛日程表可以通过n/2个选手的比赛日程表来决定。递归地用这种一分为二的策略对选手进行划分，直到只剩下两个选手时，比赛日程表的制定就变得很简单。这时只要让这两个选手进行比赛就可以了。如上图，所列出的正方形表是8个选手的比赛日程表。其中左上角与左下角的两小块分别为选手1至选手4和选手5至选手8前3天的比赛日程。据此，将左上角小块中的所有数字按其相对位置抄到右下角，又将左下角小块中的所有数字按其相对位置抄到右上角，这样我们就分别安排好了选手1至选手4和选手5至选手8在后4天的比赛日程。依此思想容易将这个比赛日程表推广到具有任意多个选手的情形 

  1. #include<iostream>
  2. using namespace std;
  3. int pre[1005][1005];
  4. void print(int n){
  5. 	for(int i=0;i<n;i++){
  6. 		for(int j=0;j<n;j++){
  7. 			cout<<pre[i][j]<<" ";
  8. 		}
  9. 		cout<<endl;
  10. 	}
  11. }
  12. void copy(int x1,int y1,int x2,int y2,int n){
  13. 	for(int i=0;i<n;i++){
  14. 		for(int j=0;j<n;j++){
  15. 			pre[x2+i][y2+j]=pre[x1+i][y1+j];
  16. 		}
  17. 	}
  18. }
  19. void range_shedule(int x,int y,int n){
  20. 	if(n==1)
  21. 		return;
  22. 	range_shedule(x,y,n/2);
  23. 	range_shedule(x,y+(n/2),n/2);
  24. 	copy(x,y,x+n/2,y+n/2,n/2);
  25. 	copy(x,y+n/2,x+n/2,y,n/2);
  26. }
  27. int main(){
  28. 	int k;
  29. 	cout<<"输入k"<<endl;
  30. 	cin>>k;
  31. 	int n=1;
  32. 	for(int i=1;i<k;i++){
  33. 		n*=2;
  34. 	}
  35. 	for(int i=0;i<n;i++){
  36. 		pre[i][0]=i+1;
  37. 		pre[0][i]=i+1;		
  38. 	}
  39.     range_shedule(0,0,n);
  40.     print(n);
  41.     return 0;
  42. }

二.动态规划

1.矩阵连乘问题

   若使用穷举搜索法，其复杂度是随着n的增长呈指数增长的，可以使用动态规划的算法来解决，即求其最优子结构。

设Ai Ai+1…Aj记作A[i:j]，设A[i:j] 1<=i <= j <= n,所需要的最少数乘次数为dp[i][j].则有：

             dp[i][j] = 0, i = j;

             dp[i][j] = min{dp[i][k] + dp[k+1][j] + pi-1*pk*pj }, i < j .（枚举k的位置）

path[][]用来记录最优解的位置，最后通过递归的方式，确定最后的计算次序。

  1. #include<iostream>
  2. #include<cstring>
  3. using namespace std;
  4. int p[1005];
  5. int dp[1005][1005];
  6. int path[1005][1005];
  7. int n=5;
  8. void Traceback(int i,int j){//输出路径 
  9. 	if(i==j)
  10. 		return ;
  11. 	Traceback(i,path[i][j]);
  12. 	Traceback(path[i][j]+1,j);
  13. 	cout<<"Multipaly A ("<<i<<"，"<<path[i][j];
  14. 	cout<<") and A ("<<path[i][j]+1<<"，"<<j<<")"<<endl;
  15. }
  16. int main(){
  17. 	int t;
  18. 	cin>>t;
  19. 	while(t--){
  20. 		for(int i=0;i<=n;i++){
  21. 			cin>>p[i];
  22. 		}
  23. 		memset(dp,0,sizeof(dp));
  24. 		memset(path,0,sizeof(path)); //初始化 
  25. 		for(int i=1;i<=n;i++){
  26. 			dp[i][i]=0;
  27. 		}
  28. 		for(int r=2;r<=n;r++){//第几个对角线 
  29. 			for(int i=1;i<=n-r+1;i++){//对角线上的元素个数（上三角） 
  30. 				int j=i+r-1;
  31. 				dp[i][j]=dp[i+1][j]+p[i-1]*p[i]*p[j];
  32. 				path[i][j]=i;
  33. 				for(int k=i+1;k<j;k++){//取k 
  34. 					int t=dp[i][k]+dp[k+1][j]+p[i-1]*p[k]*p[j];
  35. 					if(t<dp[i][j]){
  36. 						dp[i][j]=t;
  37. 						path[i][j]=k;
  38. 					}
  39. 				}
  40. 			}
  41. 		}
  42. 		cout<<dp[1][n]<<endl;
  43. 		Traceback(1,n);
  44. 		cout<<endl;
  45. 	}
  46. }

2.最长公共子序列

设序列X={X1，X2 ...... Xm}和Y={Y1,Y2.......Yn}的最长公共子序列为Z={Z1,Z2......Zk}则

 

 

从上述的结论可以看出，两个序列的最长公共子序列问题包含两个序列的前缀的最长公共子序列，因此，最长公共子序列问题具有最优子结构性质，在设计递归算法时，不难看出递归算法具有子问题重叠的性质

设C[i,j]表示Xi 和Yj 的最长公共子序列的长度，如果i=0或j=0即一个序列长度为0时，那么最长公共子序列的长度就是0，根据最长公共子序列问题的最优子结构的性质，可以有以下公式：

 

 

使用动态规划算法解决此问题，可采用从简单到复杂的方式进行计算。在计算的过程中，保存已解决的子问题答案。每个子问题只计算一次，而在后边需要时只需要简单的查一下，从而避免大量的重复计算。还是用了path数组存下了路径信息，在计算结束后可以采用递归的算法打印出最长公共子序列。

  1. #include<iostream>
  2. #include<cstring>
  3. #include<cmath>
  4. using namespace std;
  5. char x[1005],y[1005];
  6. int dp[1005][1005];
  7. int path[1005][1005];
  8. int t;
  9. void print_path(int i,int j){//打印路径 
  10. 	if(i==0||j==0)
  11. 		return ;
  12. 	if(path[i][j]==1){
  13. 		print_path(i-1,j-1);
  14. 		cout<<x[i];
  15. 	}else if(path[i][j]==2)
  16. 		print_path(i-1,j);
  17. 	else
  18. 	   print_path(i,j-1);
  19. }
  20. int main(){
  21. 	cin>>t;
  22. 	while(t--){
  23. 		scanf("%s%s",x,y);
  24. 		memset(dp,0,sizeof(dp));
  25. 		memset(path,0,sizeof(path));//初始化 
  26. 		int n=strlen(x);
  27. 		int m=strlen(y);
  28. 		for(int i=n;i>=0;i--)//将两个字符序列改成由下标1开始 
  29. 			x[i]=x[i-1];
  30. 		for(int j=m;j>=0;j--)
  31. 			y[j]=y[j-1];
  32. 		for(int i=1;i<=n;i++){
  33. 			for(int j=1;j<=m;j++){
  34. 				if(x[i]==y[j]){
  35. 					dp[i][j]=dp[i-1][j-1]+1;
  36. 					path[i][j]=1;		
  37. 				}
  38. 				else if(dp[i-1][j]>=dp[i][j-1]){
  39. 					dp[i][j]=dp[i-1][j];
  40. 					path[i][j]=2;
  41. 				}else{
  42. 					dp[i][j]=dp[i][j-1];
  43. 					path[i][j]=3;
  44. 				}
  45. 			}
  46. 		}
  47. 		cout<<dp[n][m]<<endl;//输出最优解 
  48. 		print_path(n,m);//打印公关子序列 
  49. 		cout<<endl;
  50. 	}
  51. 	 return 0;
  52. }

3.最大字段和

  1. #include<iostream>
  2. #include<cmath>
  3. using namespace std;
  4. int n;
  5. int a[1005],dp[1005];
  6. int main(){
  7. 	while(1){
  8. 		cin>>n;
  9. 		int Max=-1;
  10. 		if(n==0) break;
  11. 		for(int i=0;i<n;i++) cin>>a[i];
  12. 		if(a[0]<0) dp[0]=0;
  13. 		else dp[0]=a[0];//处理第一个数 
  14. 		for(int i=1;i<n;i++) dp[i]=max(dp[i-1]+a[i],a[i]);//暂存 
  15. 		for(int i=0;i<n;i++) Max=max(Max,dp[i]);
  16. 		cout<<"最大字段和是 "<<Max<<endl;
  17. 	}
  18. 	return 0;
  19. }

4.图像压缩

5.0-1背包问题

6.最优二叉搜索树

三.贪心

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/891004
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号