八大算法思想

最新推荐文章于 2023-10-13 14:39:20 发布
最新推荐文章于 2023-10-13 14:39:20 发布
阅读量1.8k 收藏 24
点赞数 4
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZMHshare/article/details/51997438
版权

下面介绍一下最常用的八大算法思想

一、比较“笨”的枚举算法

         基本思路：

                   1、确定枚举对象、枚举范围和判定条件
                   2、注意枚举可能的解，验证每个节是否是问题的解

         枚举算法步骤：

                   1、题解的可能范围，补能遗漏任何一个真正解，也要避免有重复

                   2、判断是否真正解的方法

                   3、使可能解的范围降至最小，以便提高解决问题的效率

#include <stdio.h>

int main()
{
	int x,y,z;
	for(x=0;x<=20;x++)
	{
		for(y=0;y<=33;y++)
		{
			z=100-x-y;
			if(z%3==0 && x*5+y*3+z/3==100)
			{
				printf("公鸡：%d,母鸡：%d,小鸡：%d\n",x,y,z);
			}
		}
	}
	return 0;
}



二、递推算法思想

         1、顺推法：从已知条件出发，逐步推算出要解决问题的方法。（斐波那契数列）

#include <iostream>
#include <vector>

using namespace std;
void get_tuzi(int mouth);
int main()
{
	int x,y,z;
	int mouth;
	cin>>mouth;
	get_tuzi(mouth);	
	return 0;
}

void get_tuzi(int mouth)
{
	vector<int> n(mouth);
	n[0]=0;
	n[1]=1;
	for(int i=2;i<mouth+1;i++)
	{
		n[i]=n[i-1]+n[i-2];
	}
	cout<<n[mouth]<<endl;
}


         2、逆推法：从已知结果出发，用迭代表达式逐步推算出要解决问题开始的条件，即顺推法的逆过程。

#include <stdio.h>

#define FETCH 1000
#define RATE  0.0171

int main()
{
	double corpus[49];
	int i;
	corpus[48]=(double)FETCH;
	for(i=47;i>0;i--)
	{
		corpus[i]=(corpus[i+1])/(1+RATE/12)+FETCH;
	}
	printf("%.2f",corpus[47]);
}


三、递归算法思想

         特点：

                   1、递归过程一般通过函数或子过程来实现。

                   2、递归算法在函数或子过程的内部，直接或者间接地调用自己的算法。、

                   3、递归算法实际上是把问题转化为规模缩小了的同类问题的子问题，然后在递归调用函数或者子过程来表示问题的解。

         注意以下几点：

                   1、递归式在过程或函数中调用自身的过程。

                   2、在使用递归时，必须有一个明确的递归结束条件，称为递归出口

                   3、递归算法通常显得很简洁，但是运行效率低，一般不提倡

                   4、在递归调用过程中，系统用栈来存储每一层的返回点和局部量，如果次数过多。容易溢出，一般不提倡使用。

                   （汉诺塔问题、阶乘问题）

#include <iostream>

using namespace std;
void hannuo(int n,char a,char b,char c);
int main()
{
	int n;
	cin>>n;
	hannuo(n,'A','B','C');
	return 0;
}

void hannuo(int n,char a,char b,char c)
{
	if(n==1)
		cout<<a<<"-->"<<c<<endl;
	else
	{
	hannuo(n-1,a,c,b);
	cout<<a<<"-->"<<c<<endl;
	hannuo(n-1,b,a,c);	
	}
}

阶乘： 

#include <iostream>

using namespace std;
int jiecheng(int n);
int main()
{
	cout<<jiecheng(2)<<endl;
	return 0;
}

int jiecheng(int n)
{
	if(n==0) return 1;
	else 
	{
		return (jiecheng(n-1)*n);
	}
}


四、分治算法思想

         1、分解，将要解决的问题划分成若干个规模较小的同类问题；

         2、求解，当子问题化分足够小时，用较简单的方法解决；

         3、合并，按原问题的要求，将子问题的解逐层合并构成原问题的解。

                     （大数相乘、比赛日程安排）

#include <stdio.h>
#include <malloc.h>
#include <string.h>

void mult(char a[],char b[],char s[]);

void main()
{
	char *a="123",*b="456";
	char *s=(char *)malloc(sizeof(char)*8);
	mult(a,b,s);
	printf("%s\n",s);
}


void mult(char a[],char b[],char s[])
{
	int i,j,k=0,alen,blen,sum=0,res[65][65]={0},flag=0;
	char result[65];
	alen=strlen(a);
	blen=strlen(b);
	for (i=0;i<alen;i++)
		for (j=0;j<blen;j++) 
			res[i][j]=(a[i]-'0')*(b[j]-'0');
	for (i=alen-1;i>=0;i--)
	{
		for (j=blen-1;j>=0;j--)
			sum=sum+res[i+blen-j-1][j];
		result[k]=sum%10;
		k=k+1;
		sum=sum/10;
		printf("%d\n",result[k-1]);
	}
	for (i=blen-2;i>=0;i--)
	{
		for (j=0;j<=i;j++) 
			sum=sum+res[i-j][j];
		result[k]=sum%10;
		k=k+1;
		sum=sum/10;
		printf("%d\n",result[k-1]);
	}
	if (sum!=0) {result[k]=sum;k=k+1;}
	for (i=0;i<k;i++) result[i]+='0';
	for (i=k-1;i>=0;i--) s[i]=result[k-1-i];
	s[k]='\0';
	while(1)
	{
		if (strlen(s)!=strlen(a)&&s[0]=='0')
			strcpy(s,s+1);
		else
			break;
	}
}

#include <iostream>
#include <iomanip>

using namespace std;
int a[65][65]={0};
void gamecal(int k,int n);
int main()
{
	int n,i,j=2;
	cin>>n;
	if(n<=2||n>64) return 0;
	while(n!=j)
	{
		j=j*2;
		if(j>64) return 0;
	}
	gamecal(1,n);
	cout<<left;
	cout<<setw(5)<<"编号";
	cout<<right;
	for(j=2;j<=n;j++)
		cout<<setw(5)<<j-1<<"天";
	cout<<endl;
	for(i=1;i<=n;i++)
	{	cout<<left;
		for(j=1;j<=n;j++)
			cout<<setw(8)<<a[i][j];
		cout<<endl;
	}
	return 0;
}

void gamecal(int k,int n)
{
	int i,j;
	if(n==2)
	{
		a[k][1]=k;
		a[k][2]=k+1;
		a[k+1][1]=k+1;
		a[k+1][2]=k;
	}
	else
	{
		gamecal(k,n/2);
		gamecal(k+n/2,n/2);
		for(i=k;i<k+n/2;i++)
			for(j=n/2+1;j<=n;j++)
				a[i][j]=a[i+n/2][j-n/2];
		for(i=k+n/2;i<k+n;i++)
			for(j=n/2+1;j<=n;j++)
				a[i][j]=a[i-n/2][j-n/2];
	}
}


五、贪心算法思想

         从问题的某一个初始解出发，逐步逼近给定的目标，一遍尽快求出更好的解。当达到算法中的某一部不能再继续前进时，就停止算法，给出一个近似解

         存在的问题

                   1、不能保证最后的结果是最优的

                   2、不能用来求最大或最小解的问题

                   3、只能求满足某些约束条件的可行解的范围

         基本思路

                   1、建立数学模型来描述问题

                   2、把求解的问题分成若干个子问题

                   3、把子问题的局部最优解合并成原来界问题的一个解

         基本过程

                   1、从问题的某一初始解出发

                   2、while能向给定总目标前进一步

                   3、求出可行解的一个解元素

                   4、由所有解元素组合成问题的一个可行解。

贪心之钱找零

#include <iostream>
#include <iomanip>

using namespace std;

#define MAXN 9

int parvalue[MAXN]={10000,5000,2000,1000,500,100,50,20,10};
int num[MAXN]={0};

void exchange(int n)
{
	int i,j;
	for(i=0;i<MAXN;i++)
		if(n>parvalue[i]) break;
	i--;
	while(n>0 && i<MAXN)
	{
		if(n>=parvalue[i])
		{
			cout<<"sdsd"<<endl;
			n=n-parvalue[i];
			num[i]++;
		}
		else if(n<11 && n>=5) 
		{
			num[MAXN-1]++;
			break;
		}
		else i++;
	}
}

int main()
{
	int i;
	float m;
	cin>>m;	
	exchange((int)(100*m));
	for(i=0;i<MAXN;i++)
	{
		cout<<setiosflags(ios::fixed)<<setprecision(3)<<(double)parvalue[i]/100<<"   "<<num[i]<<endl;
	}
	return 0;
}

贪心之装箱 

#include <stdio.h>
#include <stdlib.h>

#define N 6
#define V 100

typedef struct box
{
	int no;
	int size;
	struct box *next;
}BOX;

void init_list(BOX **H)
{
	*H=(BOX *)malloc(sizeof(BOX));
	(*H)->no=0;
	(*H)->size=0;
	(*H)->next=NULL;
}

BOX* find_p(BOX *H,int volume)
{
	BOX *p=H->next;
	while(p!=NULL)
	{
		if(p->size+volume<=V) break;
		p=p->next;
	}
	return p;
}
void add_list_tail(BOX *H,BOX *p)
{
	BOX *tmp=H->next;
	BOX *q=H;
	while (tmp!=NULL)
	{
		q=tmp;
		tmp=tmp->next;
	}
	q->next=p;
}
void print_list(BOX *H)
{
	BOX *p=H->next;
	while(p!=NULL)
	{
		printf("%d:%d\n",p->no,p->size);
		p=p->next;
	}
}
int add_box(int volume[])
{
	int count=0;
	int i;
	BOX *p;
	BOX *H=NULL;
	init_list(&H);
	for(i=0;i<N;i++)
	{
		p=find_p(H,volume[i]);
		if(p==NULL)
		{
			count++;
			p=(BOX *)malloc(sizeof(BOX));
			p->no=count;
			p->size=volume[i];
			p->next=NULL;
			add_list_tail(H,p);
		}
		else 
			p->size+=volume[i];
	}
	print_list(H);
	return count;
}
int main()
{
	int ret;
	int volume[]={60,45,35,20,20,20};
	ret=add_box(volume);
	printf("%d\n",ret);
	return 0;
}


六、试探算法思想

         1、针对所给问题，定义问题的解空间。

         2、确定易于搜索的解空间结构

         3、以深度优先搜索空间，并在搜索过程中用剪枝函数避免无效搜索。`

经典例子：八皇后

#include <stdio.h>

#define N 8

int set[N],count,sols;
int judge_place(int row)
{
	int j;
	for(j = 0;j < row;j++)
		if(row - j == set[row] - set[j] || row + set[row] == j + set[j] || set[row] == set[j])
			//（1）判断是否在同一下斜线上（2）判断是否在同一上斜线上（3）判断是否在同一列上
			return 0;
	return 1;
}

void place(int row)
{
	int i;
	if(row == N)
	{
		sols++;
		for(i=0;i<N;i++)
			printf("%d\t",set[i]);
		printf("\n");
	}
	else 
		for(i=0;i<N;i++)
		{
			set[row]=i;
			if(judge_place(row))	
				place(row+1);		
		}	
}

int main()
{
	place(0);
	printf("共有%d方案：\n",sols);
	return 0;
}


七、迭代算法

         1、确定迭代变量：在可以使用迭代算法解决的问题中，至少存在一个迭代变量，即直接或间接地不断有救治递推出心智的变量。

         2、建立迭代关系式：迭代关系式

求近似平方根

#include <iostream>
#include <cmath>

using namespace std;

int main()
{
	double a,x0,x1;
	cin>>a;
	if(a<0) 
	{
		cout<<"Error!"<<endl;
		return 0;
	}
	x0 = a / 2;
	x1 = (x0 + a / x0) / 2;
	while (fabs(x0-x1) >= 1e-6)
	{
		x0=x1;
		x1 = (x0 + a / x0) / 2;
	}
	cout<<"sart(a) = "<<x1<<endl;
	return 0;
}


八、模拟算法思想

         模拟是对真实事物或者过程的虚拟。在编程时为了实现某个功能，可以用语言来模拟该功能，模拟成功也就相应的表示编程的成功


八大算法基础思想
h21396577548的博客
11-05 7162
八大基础算法思想 算法和数据结构是每个程序员都必须修炼的内功，在面试的时候或多或少都会被问到一些算法相关的问题。 算法的应用不单只体现在编程中。狭义的来讲，算法可看作是数据传递和处理的顺序、方法和组成方式，就像是各种排序算法等。广义的来讲，算法更像是一种事物运行的逻辑和规则。 算法其实是一种思维模式，本文就简单介绍一下八种常用算法思想，分别是枚举、递推、递归、分治、动态规划、贪心、回溯和模拟。 1.枚举算法 最简单的枚举算法，也被称为穷举，顾名思义就是穷尽列举。枚举思想的应用最为广泛，也最是通俗易懂。枚举思
（一）八大算法思想
weixin_34187822的博客
01-02 859
八大算法 八大算法：枚举、递推、递归、分治、贪心、试探法、动态迭代和模拟算法思想。 一、枚举算法思想（暴力算法） 　　将问题的所有可能答案一一列举，根据判断条件判断此答案是否合适，一般用循环实现。 　　经典运用：百钱买百鸡、填写运算符 二、递推算法思想 　　1.顺推法：从已知条件出发，逐步推算出要解决问题的方法。 　　2.逆推法：从已知结果出发，用迭代表达式逐步推算出问题开始的...
一文图解弄懂八大常用算法思想！
weixin_47066028的博客
08-05 884
算法和数据结构一直以来都是程序员的基本内功。 数据结构可以看作是算法实现的容器，通过一系列特殊结构的数据集合，能够将算法更为高效而可靠地执行起来。 算法的应用不单只体现在编程中。狭义的来讲，算法可看作是数据传递和处理的顺序、方法和组成方式，就像是各种排序算法等。广义的来讲，算法更像是一种事物运行的逻辑和规则。 所以对于算法的理解，重要的是领悟其思想，感受其内在。本文旨在抛砖引玉，通过图解+案例的形式，介绍了八种常用的算法思想。 1 枚 举 首先，最为简单的思想，枚举算法。枚举也叫穷举，顾名思义，就是穷尽
八大常用算法思想
君一席
02-19 975
算法和数据结构一直以来都是程序员的基本内功，可以说没有数据结构的基础建设和算法加持，也就没有这将近八十年的信息革命时代。数据结构可以看作是算法实现的容器，通过一系列特殊结构的数据集合，能够将算法更为高效而可靠的执行起来。 算法的应用不单只体现在编程中。狭义的来讲，算法可看作是数据传递和处理的顺序、方法和组成方式，就像是各种排序算法等。而广义的来讲，算法更像是一种事物运行的逻辑和规则。太阳东升西落，海水潮汐潮流，月儿阴晴圆缺，这些或许都可以看似一种算法，只不过执行者不是电子计算机，而是自然万物。 聊远了。所以
不要再死刷LeetCode啦，先掌握这常用的八大算法思想再说！枚举、递推、递归、分治、动态规划、贪心、回溯、模拟
业余码农Amazing10的博客
07-20 1433
文章首发：微信搜索『业余码农』 算法和数据结构一直以来都是程序员的基本内功，可以说没有数据结构的基础建设和算法加持，也就没有这将近八十年的信息革命时代。数据结构可以看作是算法实现的容器，通过一系列特殊结构的数据集合，能够将算法更为高效而可靠的执行起来。 算法的应用不单只体现在编程中。狭义的来讲，算法可看作是数据传递和处理的顺序、方法和组成方式，就像是各种排序算法等。而广义的来讲，算法更像是一种事物运行的逻辑和规则。太阳东升西落，海水潮汐潮流，月儿阴晴圆缺，这些或许都可以看似一种算法，只不过执行者不是电子.
五大算法基本思想—分治，动态规划，贪心，回溯，分支界限，算法数据结构
04-07
本文将深入探讨五大基础算法思想：分治、动态规划、贪心、回溯和分支界限，并与数据结构相结合，帮助我们理解和应用这些算法。 一、分治法 分治法是一种将复杂问题分解为较小、独立且相似的子问题的策略，然后对子...
八大算法思想（二）------------------递归算法
李丽的博客
06-12 1811
一，充分利用自己的递归算法思想    递归算法能够充分挖掘自身的潜力，无论遇到了什么问题，它都会直接或者间接地调用自身的算法去解决。 递归算法思想的原则是有事不求人。即使难以解决解决也要自己解决，即使难以解决也要硬着头皮去解决。递归的自身算法往往用函数的形式体现，所以递归算法需要预先编写功能函数，这些函数是独立的功能，能够实现解决某个问题的具体功能，当需要时直接调用这个函数即可。 1，递归算
利用Python实现数据结构常见的八大排序算法
02-20
常见的排序算法有八大种，它们各自有不同的特点、适用场景和时间复杂度。在Python中实现这些排序算法，不仅可以帮助我们理解排序的原理，还可以加深对Python语言特性的认识。以下是利用Python实现数据结构中常见的八...
算法入门(一)--八大算法思想学习
wbxd
03-05 432
八大算法思想 学在前面：学习编程这么长时间，只注重工程方面的学习，对拥有编程灵魂著称的算法却很陌生，只是停留在当时的数据结构的基础上，自己还有很大的学习空间，今天从入门开始，加油，奥里给！mark 笨笨的枚举算法     算法思想：在进行推理时，如果逐个考察某类事件的所有可能情况，因此得出一般结论，那么该结论是可靠的，这种归纳方法叫做枚举法。说白了就是怎...
五种基本算法思想
热门推荐
xld的博客
12-25 4万+
• 穷 举 算 法 思 想 。 • 递 推 算 法 思 想 。 • 递 归 算 法 思 想 。 • 分 治 算 法 思 想 。 • 概 率 算 法 思 想 。
图文 | 详解八大算法思想
编程与实战的博客
04-25 1379
大家好。今天是图文第二弹，老早之前写的一篇算法思想总结，有读者想要图文版。今天，它来啦！字节跳动的技术岗面试最喜欢出手撕算法题，这基本是业内出了名的事儿。之前我也因此而头疼不已。 不过好在我当时找到了合适的学习方法，才侥幸通过了一轮轮残酷的算法考验。其实算法的学习并不应该死板的刷题背题，而是需要理解万变不离其宗的思想。 ...
学习ing
ghostriderk的专栏
06-12 980
八大排序算法思想，时间复杂度，稳定性、及其java实现
向来缘浅，奈何情深
09-20 1228
八大排序算法思想，时间复杂度，稳定性、及其java实现1.归并排序package eightSort;import java.util.Arrays;/** * 归并排序 * * 1.设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为n-i +1、n-m。 * j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标 * 2.若i>m 或j
5种算法思想
UNI18660392930的博客
10-08 259
package BaseAlgo; import java.util.Scanner; /* * 递归算法：不断反复调用自身来解决问题。要求问题能够分解为相同问题的一个子问题。 * 直接递归：调用本身 * 间接递归：a 调用b b 再调用a；（用的不多） * 递归前一般有一个if语句作为递归出口，否则无限调用自身，引发堆栈溢出。 * * 实例：阶...
八大排序算法的思想
Super_xiaojian的博客
07-18 581
1   选择排序：每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止 2  冒泡排序：对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序 3   插入排序：每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。 4  希尔排序：把记录按下标的一定增量分组，对...
八大排序算法(含时间复杂度、空间复杂度、算法稳定性)
最新发布
Xpccccc的博客
10-13 6064
八大排序算法(含时间复杂度、空间复杂度、算法稳定性)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值