各算法思想总结

最新推荐文章于 2022-06-02 17:36:07 发布
最新推荐文章于 2022-06-02 17:36:07 发布
阅读量328 收藏
点赞数
分类专栏： 算法 文章标签： 数据结构与算法
若非群玉山头见 会向瑶台月下逢
本文链接：https://blog.csdn.net/weixin_38331049/article/details/88696619
版权

数据结构与算法归纳总结

1.枚举

1.1 例题: 求24

/*
递归边界：只有一个数判断是否等于24，等于24不能用==判断  只能用<某个极限
两层遍历一个选取两个数将剩下的数放在一个数组中B[]  将前两个数运算的集合放在b数组的末尾
提取的两个数有 a[i]+a[j]  a[i] - a[j] a[j] - a [i]  a[i]/a[j]  a[j] /a[i]  a[i]*a[j]
任意情况成立则 总成立
所有情况不成立则不成立 
*/

#include<iostream>
#include<cmath> 
using namespace std;
double a[5];
#define EPS 1e-6
bool isZero(double x)
{
	return fabs(x) <= EPS;
}
bool count24(double a[], int n)
{
	if( n == 1)   				//边界条件 
	if(isZero(a[0] - 24))
		return true;
	else
		return false;
		
	double b[5];
	for(int i = 0;i  < n-1;i++ )    //a[i]   和a[j] 用来运算的两个数 
	{
		for(int j = i+1; j < n; ++j)
		{
			int m = 0;  	//	还剩m个数  m = n-2; 
			for( int k = 0; k < n; k++)
				if(k != i && k != j)     //枚举把其余数放入b中 
					b[m++] = a[k];
					b[m] = a[i] + a[j]; 
				if(count24(b,m+1))
					return true;
					b[m] = a[i]-a[j]; 
				if(count24(b,m+1))
					return true;
					b[m] = a[j] - a[i]  ;
				if(count24(b,m+1))
					return true;
					b[m] = a[i]*a[j];
				if(count24(b,m+1)) 
					return true;
				if(!isZero(a[j])) 
				{
					b[m] = a[i] / a[j];
					if(count24(b,m+1))
						return true;
				}
				if(!isZero(a[i]))
				{
					b[m] = a[j]/a[i];
					if(count24(b,m+1))
						return true;
				}
		}
		return false;
	}
	
}
int main()
{
	for(int i = 0; i < 4; i++)
	{
		cin >> a[i];
	}
	if(count24(a,4))
		cout << "true" ;
	else
		cout << "false";
 }

1.2 设计思想

1.将问题所有的可能性一一列举

2.保留合适的，排除不合适的。

PS:列举所有的数字组合情况，然后进行判断。

1.3 算法模板

循环
情况： <S>
for(x:S)
{
	if judge(x) == true;
    save x;
    else
    no do;
}

递归遍历情况
void f()
{
    if(S.empty())
        return ;
    取出S中的一个x
   	if(judge(x))
        save
    else
        f(x+1)；
    
}

2.分治

2.1 例题 快速排序

#include<iostream>
#include<algorithm>
using namespace std;
void quick_sort(int a[], int s, int e)
{
	if(s >= e)
		return ;
	int k = a[s];
	int i = s,j = e;
	while(i != j)
	{
		while(j > i && a[j] >= k)
			--j;
			swap(a[i],a[j]);
		while(i < j && a[i] <= k)
			++i;
			swap(a[i],a[j]);
	}
	quick_sort(a,s,i-1);
	quick_sort(a,i+1,e);
}
int main()
{
	int a[8]={4,5,2,1,8,9,6};
	quick_sort(a,0,8);
	for(int i = 0;i < 8; i++)
		cout << a[i];
 } 
/*
	7 8 5 6 4 1 2 3 9
*/

2.2 设计思想

  1. 父问题能无限划分成小问题，且子问题之间不相互影响。
  2. 所有子问题的解集合能得到父问题的解

在上述快速排序中，每一个元素的左边小于自己，右边大于自己即排序完成。

2.3 算法模板

begin 　｛分治过程开始｝
　　　 if ①问题不可分 then ②返回问题解 　
　　　　 else begin
　　　　　　 　　 ③从原问题中划出含一半运算对象的子问题1；
　　　　　　 　　 ④递归调用分治法过程，求出解1；
　　　　　　 　　 ⑤从原问题中划出含另一半运算对象的子问题2；
　　　　　　 　　 ⑥递归调用分治法过程，求出解2； 
　　　　　　 　　 ⑦将解1、解2组合成整修问题的解； 　
　　　　　　　 end;
　　 end; {结束}

3.递归

3.1 题目 N皇后问题

#include<iostream>
#include<cmath>
#include<stdio.h>
using namespace std;
int room[9][9],lie[9],sum = 0;  //data 
void fun(int t)  //t hang find lie
{
	if(t == 9)  
	{
		int SUM = 0;
		for(int i =1;i < 9;i++)
		SUM += room[i][lie[i]];
		if(SUM > sum)
		sum  = SUM;
		return ;
	}
	int i;
	for(i = 1;i <= 8;i++)
	{
		int j;
		for(j = 1;j < t;j++)
		{
			if(i == lie[j]||abs(lie[j] - i) == abs(j - t))	
			break;
		}
		if(t == j)
		{
			lie[t] = i;
			fun(t+1);
		}
	}
	
}
int main()
{
	freopen("input.txt","r",stdin);
	for(int i = 1;i < 9;i++)
	for(int j = 1;j < 9;j++)
	cin >> room[i][j];
	fun(1);
	cout << sum << endl;
}

3.2 算法思想

3.2.1结构性递归
  1. 类似二叉树的不断分支
  2. 先左节点，后右节点
3.2.2 过程型递归
  1. 汉诺塔问题。
3.2.3 总结

不论结构型递归还是过程性递归，都必须要抛弃程序的细节，只关注程序的功能

3.3 模板

过程性递归
void fun(int n)
{
	if(达到出口的条件)
    {
        判断是否符合要求
            return；
    }
    fun(n+1);
}
结构型递归
void dfs()
{
    if(达到根节点返回)
	dfs(左边)；
    dfs(右边)；
    deal(自己)
}

4.动态规划

4.1 案例 未命名湖畔的烦恼

#include<stdio.h>
typedef long long ll;  
using namespace std;  
  
  
int f(int m,int n)  
{  
    if(m < n)  
        return 0;  
    if(n == 0)  
        return 1;  
    return f(m-1,n) + f(m,n-1);  
}  
  
int main()  
{  
    int m,n;  
    while(scanf("%d%d",&m,&n) != EOF)  
    {  
        int sum = f(m,n);  
        printf("%d\n",sum);  
    }  
    return 0;  
}

4.2 算法思想

  1. 问题可以递归实现也可以滚动数组实现
  2. 动态规划算法注意可以求得得边界
  3. 原始问题是边界得重复迭代

4.3 算法模板

递归实现
int f(int m,int n)  
{  
    if(m == 0)  
        return 0;  
    if(n == 0)  
        return 1;  
    return f(m-1,n) + f(m,n-1);  
} 
滚动数组实现
a[N][N]
for(i->N)
    a[i][0]=num;
	a[0][i]=num;
for(i:N)
{
    for(j:N)
    {
        a[i][j] = max(a[i-1][j],a[i][j-1]);
    }
}

5.广度优先搜索

5.1 案例 学霸的迷宫

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
struct pos{
	int x, y;
	int num;
};
int n, m;
char map[550][550];
int vis[550][550];
int dir[4][2] = {1, 0, 0, -1, 0, 1, -1, 0};
int pre[550][550];
char str[5] = {"DLRU"};
void bfs() {
	queue <pos> q;
	pos t;
	t.x = 1, t.y = 1, t.num = 0;
	q.push(t);
	vis[1][1] = 1;
	pre[1][1] = -1;
	while(!q.empty()) {
		t = q.front();
		q.pop();
		if(t.x == n && t.y == m) {
			printf("%d\n", t.num);
			return ;
		}
		int i, j;
		pos tt;
		for(i = 0; i < 4; i++) {
			tt.x = t.x + dir[i][0];
			tt.y = t.y + dir[i][1];
			tt.num = t.num + 1;
			if(tt.x >= 1 && tt.x <= n && tt.y >= 1 && tt.y <= m && map[tt.x][tt.y] == '0' && vis[tt.x][tt.y] == 0) {
				pre[tt.x][tt.y] = i;
				q.push(tt);
				vis[tt.x][tt.y] = 1;
			}
		}
	}
}
void path(int x, int y) {
	if(x == 1 && y == 1) return;
	path(x - dir[pre[x][y]][0], y - dir[pre[x][y]][1]);
	printf("%c", str[pre[x][y]]);
}
int main () {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	scanf("%d %d", &n, &m);
	getchar();
	int i, j;
	for(i = 1; i <= n; i++) {
		for(j = 1; j <= m; j++) {
			scanf("%c", &map[i][j]);
		}
		getchar();
	}
	bfs();
	path(n, m);
	return 0;
}

5.2算法思想

  1. 从一点出发找到附近的节点看是否符合要求
  2. 然后从相邻的节点出发，继续BFS

PS:从起始位置出发，一步一步搜索，每步标记自己从哪里走过来的。

5.3 算法模板

q.push(head);
while(!q.empty())
{
	temp=q.front();
	q.pop();
	if(tempÎ为目标状态)
		输出或记录
	if(temp不合法 )
		continue;
	if(temp合法)
		q.push(temp+¦Δ ); 
}

6. 深度优先搜索

6.1 案例 N皇后

#include<iostream>
#include<cmath>
#include<stdio.h>
using namespace std;
int room[9][9],lie[9],sum = 0;  //data 
void fun(int t)  //t hang find lie
{
	if(t == 9)  
	{
		int SUM = 0;
		for(int i =1;i < 9;i++)
		SUM += room[i][lie[i]];
		if(SUM > sum)
		sum  = SUM;
		return ;
	}
	int i;
	for(i = 1;i <= 8;i++)
	{
		int j;
		for(j = 1;j < t;j++)
		{
			if(i == lie[j]||abs(lie[j] - i) == abs(j - t))	
			break;
		}
		if(t == j)
		{
			lie[t] = i;
			fun(t+1);
		}
	}
	
}
int main()
{
	freopen("input.txt","r",stdin);
	for(int i = 1;i < 9;i++)
	for(int j = 1;j < 9;j++)
	cin >> room[i][j];
	fun(1);
	cout << sum << endl;
}

6.2 设计思想

  1. 从一个节点出发，不断向下寻找，
  2. 经过的节点标记走过
  3. 遇到无法寻找即返回。

6.3 算法模板

void dfs(状态A)
{
	if(A不合法)
		return;
	if(A为目标状态)
		输出或记录路径
	if(A不为目标状态)
		dfs(A+Δ ) 
 }
玲珑·
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法之排序算法的算法思想和使用场景总结
09-04
排序算法是计算机科学中至关重要的基础算法之一，它在数据处理和分析中起着核心作用。本文主要聚焦于几种常见的基于比较的排序算法，...理解各种排序算法的思想和应用场景，有助于我们写出更高效、适应性更强的代码。
算法之五大算法思想
u010006156的博客
05-21 1353
文章目录 一、数据库自增长ID 1.定义 2.优缺点 3.应用场景 二、uuid生成ID 1.定义 2.优缺点 3.应用场景 三、Redis生成ID 1.定义 2.优缺点 3.应用场景 四、雪花算法 snowflake 1.定义 2.优缺点 3.应用场景 五、美团leaf 1.号段模式 1.1 定义 1.2 双buffer设计 1.3 优点 1.3 缺点 2.雪花模式 2.1 定义 2.2 时间回拨问题 2.3 优缺点
13算法策略总结与比较
weixin_30359021的博客
02-15 668
算法策略间的比较 算法策略和算法是有区别的,它们是算法设计中的两个方面，算法策略是面向问题的,算法是面向实现的；但二者又是不可分的,首先是通过算法策略才找出解决问题的算法，其次对于用不同算法求解的问题算法策略是自然不同的。 “贪婪算法” 这些策略求解的是最简单的一类问题，或者说是对问题要求最严格的算法策略。“贪婪算法”解决这类问题是按一定顺序（从前向后或从后向前等）一定...
算法笔记2
weixin_34161032的博客
06-17 385
分治法：是将待求解的原问题划分成若干个相互独立的子问题，通过求解子问题并将子问题的解合并，自底向上逐步求出原问题的解。 动态规划法：是将待求解问题分解成若干个相互重叠的子问题，每个子问题对应决策过程的一个阶段，一般来说，子问题的重叠关系表现在对给定问题求解的递推关系（也就是动态规划函数）中，将子问题的解求解一次并填入表中，当需要再次求解此子问题时，可以通过查表获得该子问题的解而不用再次求解，...
Adboost算法
yan的博客
06-01 1278
一、发展历史Boosting算法是一种把若干个分类器整合为一个分类器的方法，在boosting算法产生之前，还出现过两种比较重要的将多个分类器整合 为一个分类器的方法，即boostrapping方法和bagging方法。我们先简要介绍一下bootstrapping方法和bagging方法。　　1）bootstrapping方法的主要过程　　主要步骤：　　i)重复地从一个样本集合D中采样n个样本　　...
八大算法基础思想
h21396577548的博客
11-05 6822
八大基础算法思想 算法和数据结构是每个程序员都必须修炼的内功，在面试的时候或多或少都会被问到一些算法相关的问题。 算法的应用不单只体现在编程中。狭义的来讲，算法可看作是数据传递和处理的顺序、方法和组成方式，就像是各种排序算法等。广义的来讲，算法更像是一种事物运行的逻辑和规则。 算法其实是一种思维模式，本文就简单介绍一下八种常用算法思想，分别是枚举、递推、递归、分治、动态规划、贪心、回溯和模拟。 1.枚举算法 最简单的枚举算法，也被称为穷举，顾名思义就是穷尽列举。枚举思想的应用最为广泛，也最是通俗易懂。枚举思
归并算法思想总结
07-17
归并算法思想总结
四大算法思想1
08-03
总结起来，这四种算法思想各有特点，回溯算法适用于多种问题，但效率相对较低；分治算法适用于可分解为独立子问题的问题；贪心算法在满足特定条件下能找到局部最优解，但不保证全局最优；动态规划则能解决存在大量...
数据结构与算法课程总结
03-04
本课程主要围绕《数据结构与算法设计》一书展开，通过“算法思想——算法实现过程分析——算法实现程序——性能分析”的流程，深入讲解了多种数据结构和算法，并以C语言为实现语言。 首先，第一章“数据结构和算法...
数据结构与算法程序示例。常用算法思想总结归档。使知识体系化.zip
最新发布
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
基本算法思想总结
weixin_49543720的博客
03-30 812
无论是在大学还是培训机构，无论是在java还是在C，算法始终贯彻其中，扮演着是不容忽视的角色。而算法的精髓就在于其思想，或者说是解题思路，一个清晰的解题思路，是解决问题的致胜法宝。本文就来总结一下一些基本的算法思想。 首先，我们抛出心中的疑问：算法是什么？算法，即是按照一定的步骤，一步步去解决某个问题，解决问题的方法步骤称之为算法，例如数学中我们学过的做一个运算，解一个方程，等等，都需要有一个清晰的思路，一步步地去完成。当然这只是我们学习中的例子，生活中，我们结算工资也是要按一定的步骤，完成一个闭合的运算，
数据结构和算法-知识点总结
qq_17200461的博客
03-04 1598
时间复杂度: 1、假设计算机执行每个基本操作的时间是固定的时间单位，那么有多少基本操作就代表有多少时间单位。虽然不同机器的时间单位不同，但是执行基本操作基本是相同的，因此可以使用步骤来客观描述代码的时间复杂度。 2、时间复杂度用大（O）记法表示。 ...
五种基本算法思想
xld的博客
12-25 4万+
• 穷 举 算 法 思 想 。 • 递 推 算 法 思 想 。 • 递 归 算 法 思 想 。 • 分 治 算 法 思 想 。 • 概 率 算 法 思 想 。
常见的算法思想（整理）
姓谢名谢
04-29 4122
1、算法特征 算法的英文名称是Algorithm，这个词在1957年之前在Webster’s New World Dictionary(《韦氏新世界词典》)中还未出现，只能找到带有它的古代涵义的较老形式的“Algorism”(算术)，是指用阿拉伯数字进行算术运算的过程。在中世纪时，珠算家用算盘进行计算，而算术家用算术进行计算。 根据经验和发展结论得出，算法应该具有如下五个重要的特征。 （1）...
数据结构与算法（总结）
热门推荐
weixin_45397053的博客
04-23 5万+
总结： 一、数据结构（Data Structure） 是数据的组织结构，用来组织、存储数据。算法（Algorithm） 就是解决问题的方法或者过程。 二、数据结构分为逻辑结构和物理结构。逻辑结构分为集合结构、线性结构、树形结构、图形结构；物理结构分为顺序存储结构、链式存储结构。 三、算法是一系列运算步骤。算法有5个基本特性，输入、输出、有穷性、确定性、可行性；算法最求5个目标，正确性、可读性、健壮性、运行时间少、内存空间小。 四、「数组」 是实现线性表的顺序结构存储的基础；「链表」 是实现线性表的链式存储结
算法思想及数据结构 -- 总结
课桌
01-25 1412
数学数据结构算法 程序的设计过程 算法思想 动态规划 线性规划 数据结构 树 最近公共祖先Lowest Common Ancestor 网上经验数学，数据结构，算法 【王boy】学习数据结构有什么用？ 【王boy】递推与递归的区别？程序的设计过程算法思想动态规划什么是动态规划？动态规划的意义是什么？线性规划线性规划（抽象层次） 线性规划（代码实现单纯形法） 线性规划（代码注释较多）数据结构
学习ing
ghostriderk的专栏
06-12 905
算法核心思想总结及模板（不定期更新）
mr_zj_的博客
02-18 1019
写这篇博客的目的： 加强对算法的理解和概括 备忘 快排（divide-and-conquer）核心思想: 　　每一次划分将小于或等于pivot element（下面第二张图中 xx）的元素依次放在前面，则大于xx的元素就自动到后面一部分了，然后再把xx放到两部分中间（此时xx已排好序，归位），然后对左右两部分递归调用。Update：2017/2/18 筛法求素数核心思想: 　　把合数筛掉。
数据结构与算法——知识点总结
记录知识，学习分享
06-02 2万+
本文包含数据结构与算法主要的基本知识点，便于知识的梳理和回顾。 如需详细了解具体知识点请自行结合课本或者网上查阅。 目录 1、概述 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 1、概述 从 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 ...
kruskal算法思想
08-10
### 回答1： Kruskal算法是一种用于求解最小生成树的贪心算法，它的基本思想是：按照边权从小到大的顺序，逐个加入到生成树中，如果加入该边会形成环，则不加入该边，直到生成树中有n-1条边为止。具体实现过程如下： 1. 将所有边按照边权从小到大排序； 2. 依次枚举每条边，如果该边的两个端点在同一个集合中，则不加入该边，否则加入该边，并将两个端点所在的集合合并成一个集合； 3. 直到生成树的边数为n-1时停止。 Kruskal算法的时间复杂度为O(mlogm)，其中m为边数。它的优点是简单易实现，且能够在保证最小生成树的情况下尽可能地保证连通性。 ### 回答2： Kruskal算法是一种用于解决最小生成树问题的贪心算法。它的思想是从图中的所有边中选取权重最小的边，并且保证边的选取不会构成一个环，逐步构建最小生成树。 具体实现Kruskal算法的步骤如下： 1. 初始化一个空的最小生成树MST和一个边集合E，边集合E包含图中的所有边，并按照权重从小到大排序。 2. 从E中选择权重最小的边，并将其从边集合E中移除。 3. 如果选择的边不会与MST中的边构成环路，将其加入MST中。 4. 重复步骤2和3，直到MST包含了图中的所有顶点。 5. 最终得到的MST即为图的最小生成树。 Kruskal算法的关键在于如何判断选取的边是否会构成环路。为了实现这一点，可以使用并查集数据结构来记录每个顶点所属的连通分量，检查是否存在连通分量的根节点相同的两个顶点，如果存在，则选取的边会构成环路。 由于Kruskal算法每次选择权重最小的边，且这些边不会构成环路，所以最终得到的最小生成树肯定是具有最小权重的树。因此，Kruskal算法可以高效地找到图中的最小生成树。 总的来说，Kruskal算法是一种简单且高效的贪心算法，用于解决最小生成树问题。它的核心思想是选择权重最小的边，并保证选取的边不会构成环路，从而逐步构建最小生成树。 ### 回答3： Kruskal算法是一种用于构建最小生成树的贪心算法。其思想是通过不断选择边，将边逐渐添加至最小生成树中，直到最小生成树的边数达到图的节点数减一为止。 具体来说，Kruskal算法的步骤如下： 1. 将图中的所有边按照权重从小到大进行排序。 2. 创建一个空的最小生成树。 3. 循环遍历排序后的边，每次选择权重最小的边。 4. 判断选择的边是否存在于最小生成树中。如果不存在，将其加入最小生成树中；如果存在，则舍弃该边。 5. 重复步骤3和步骤4，直到最小生成树的边数达到图的节点数减一。 Kruskal算法的核心思想是通过选择边来逐步扩展最小生成树，并且保证选取的边不形成环路。在每次选择边时，判断是否会导致环路的出现，可以使用并查集进行高效的判断。只有当选取的边不会导致环路时，才将其加入最小生成树中。 Kruskal算法的时间复杂度取决于排序边的时间复杂度，通常使用快速排序等时间复杂度为O(ElogE)的排序算法。其中E为边的数量。而由于要判断选择的边是否会导致环路，需要使用并查集来进行高效的判断，其时间复杂度为O(VlogV)，其中V为图的节点数。 总结来说，Kruskal算法是一种贪心算法，通过选择权重最小的边来逐步构建最小生成树。它的思想简单且易于理解，适用于性能要求不太苛刻的情况。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值