必须记忆的算法——记忆笔记

最新推荐文章于 2024-05-20 00:01:33 发布
置顶 最新推荐文章于 2024-05-20 00:01:33 发布
阅读量629 收藏 2
点赞数
分类专栏： c++ 记忆算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22149613/article/details/88397749
版权

 高效素数打表——欧拉打表

s[i+1].find(s[i])==s[i+1].npos//  npos  表示不存在
#include<iostream>
#define maxn 100000
#define maxl 1000000
using namespace std;
int prime[maxn];
bool vis[maxl];
void get_prime(){//线性时间筛法——欧拉筛法
	int cnt=0;
	int i,j;
	for(i=2;i<maxl;i++){
		if(!vis[i]){
			prime[cnt++]=i;vis[i]=true;
		}
		for(j=0;j<cnt;j++){
			if(i*prime[j]>maxl)break;
			vis[i*prime[j]] =true;
			if(i%prime[j]==0) break; 
		}
	}
}
int main(){
	get_prime();
	for(int i=0;i<100;i++) cout<<prime[i]<<endl;
	return 0;
}

最长对称子序列——偶数，奇数

#include<iostream>
#include<algorithm>
#include<set>
#include<cstring>
using namespace std;
int main() {
	string a;
	while (getline(cin, a)) {
		int l = a.length();
		int len = 0;
		for (int i = 0; i < l; i++) {
			for (int j = 0; i - j >= 0 && i + j < l; j++) {
				if (a[i - j] != a[i + j]) break;
				if (2 * j + 1 > len) len = 2 * j + 1;
			}
			for (int j = 0; i - j >= 0 && i + j <= l; j++) {
				if (a[i - j] != a[i + j + 1]) break;
				if (2 * j + 2 > len) len = 2 * j + 2;
			}
		}
		cout << len << endl;
	} return 0;
}

最长子序列

#include<iostream>
using namespace std;
int maxs(const int a[], int n) {
	int thissum, maxsum, j;
	thissum = maxsum = 0 ;
	for (j = 0; j < n; j++) {
		thissum += a[j];
		if (thissum > maxsum) maxsum = thissum;
		else if (thissum < 0) thissum = 0;
	}
	return maxsum;
}
int main() {
	int a[1000];
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) cin >> a[i];
	int maxss=maxs(a, n);
	cout << maxss << endl;
	system("pause");
	return 0;
}

kmp 算法 ——两个字符串 匹配  输出 起始 index

#include<iostream>
using namespace std;
const int maxl = 1000000;
const int maxn = 100000;
int a[maxl], b[maxn];
int n, m, f;//m 模板长度 n 匹配串长度
int nex[maxn];
void get_next() {
	int i = 0; int j = -1;
	nex[0] = -1;
	while (j < n) {
		if (j == -1 || a[i] == b[j])nex[++i] = ++j;
		else j = nex[j];
	}
}
void kmp() {
	int i =0, j =0;

	get_next();
	while (i < m) {
		if (j == -1 || a[i] == b[j])
		{
			i++; j++;
		}
		else j = nex[j];
		if (j == n) {
			cout << i - n + 1 << endl;
			f = 0;
			break;
		}
	}
}
int main(){
	ios::sync_with_stdio(false);
	int t;
	cin >> t;
	while (t--) {
		f = 1;
		for (int i = 0; i < m; i++) cin >> a[i];
		for (int i = 0; i < n; i++) cin >> b[i];
		kmp();
		if (f) cout << "-1" << endl;
	}return 0;
}

欧几里得算法————求两个数的最大公因数

unsigned int gcd(int x, int y) {//循环实现
	unsigned int rem;
	while (y > 0) {
		rem = x % y;
		x = y;
		y = rem;
	}
	return x;
}

int gcd1(int x, int y) {//递归实现
	return y == 0 ? x : gcd(y, x%y);
}

最小公倍数 ——借助gcd()

int g(int x, int y) {
	return x / gcd(x, y)*y;
}// 先除法后乘法 防止数据溢出

 

对分查找————排好序的数组中查找某一元素T

int BinarySearch(const ElementType a[],ElwmentTpye T,int n){
	int low,mid,high;
	low=0;
	high=n-1;
	while(low<=high){
		mid=(low+high)/2;
		if(a[mid]<x){
			low=mid+1;
		}else if(a[mid]>x){
			high=mid-1;
		}else return mid;/* found*/
	}
	return -1;/*notfound*/
}

快速幂 

long int pow(long int x,long int n){
	if(n==0) return 1;
	if(n==1) return x;
	if(n%2){//奇数个 
		return pow(x*x,n/2)*x;
	}else return pow(x*x,n/2);//偶数个 
}

两点间的最短路径——固定一点到其余所有点的最短路径（Dijkstra算法）（没有负边的情况）

#include<iostream>
#include<sstream>
using namespace std;
#define M 210
#define INF 0x3f3f3f 
int arr[M][M], vis[M], dis[1010];// arr 路径 // vis 标记数组 dis  距离
int n, m;
void Dijkstra(int src) {//一点（src） 到 其余所有点的最短路径
	for (int i = 0; i < n; i++) {
		vis[i] = 0; dis[i] = arr[src][i];
	}
	int temp, k;
	vis[src] = 1; dis[src] = 0;
	for (int i = 0; i < n; i++) {
		temp = INF;
		for (int j = 0; j < n; j++) {
			if (!vis[j] && temp > dis[j]) {
				temp = dis[j];
				k = j;
			}
		}

		vis[k] = 1;
		for (int j = 0; j < n; j++) {
			if (!vis[j] && dis[j] > arr[k][j] + dis[k]) dis[j] = arr[k][j] + dis[k];
		}
	}
}
void work() {
int s, t, u, v, w;
	while (cin>>n>>m) {
		for (int i = 0; i < n; i++) for(int j=0;j<n;j++) arr[i][j] = INF;//初始化
		for (int i = 0; i < m; i++) {
			cin >> u >> v >> w;
			if(arr[u][v]>w) arr[u][v] = arr[v][u] = w;//输入 ——输入最短路径 （可能路不只有一条）
		}
		cin >> s >> t;// 需要 求得 s 到 t（也可以是其他值） 的最短路径
		Dijkstra(s);// 
		if (dis[t] != INF) cout<< dis[t]; else cout << "-1";
		puts("");
	}
}
int main() {
	work();
	
	system("pause");
	return 0;
}
//Dijkstra 算法的另一种写法
#include<iostream>
#include<cmath>
#include<math.h>
#include<sstream>
#include<cstring>
using namespace std;
#define M 110
#define INF 0x3f3f3f
int arr[M][M], vis[M], dis[1010];//三个数组都需要初始化
/*
arr数组 初始化 目的： 保证在输入的 两地之间 只记录最短的距离 （可能两地有不止一条路）
vis  标记是否被读取 走过的路不再重复
dis  初始为最远  
*/
int n, m;// n 顶点数
int min(int x, int y) {
	return x < y ? x : y;
}
void Dijkstra(int src) {//一点 到 其余所有点的最短路径
	memset(vis, 0, sizeof(vis));
		memset(dis, INF, sizeof(dis));
		dis[src] = 0;
		while (true) {
			int v = -1;
			//从尚未选择的顶点中选一个距离最小的点
			for (int i = 1; i <= n; i++) {
				if (!vis[i] && (v ==-1 || dis[i] < dis[v])) v = i;
			}
			if (v == -1) break;
			vis[v] = 1;
			for (int i = 1; i <= n; i++) {
				dis[i] = min(dis[i],dis[v] + arr[v][i]);
			}
		}
}

void work() {
int s, t, u, v, w;
	while (cin>>n>>m) {
		if (m == 0 && n == 0) break;
		for (int i = 1; i <= n; i++) for(int j=1;j<=n;j++) arr[i][j] = INF;
		for (int i = 0; i < m; i++) {
			cin >> u >> v >> w;
			if(arr[u][v]>w) arr[u][v] = arr[v][u] = w;
		}
		s = 1; t = n;
		Dijkstra(s);
		 cout << dis[t];
		puts("");
	}
}
int main() {
	work();
	
	system("pause");
	return 0;
}

最小生成树——用于求取一棵树上最近的联通距离（eg: 连接所有村庄的电线最短长度）

#include <iostream>
#include<math.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 101;

int n; //节点数
int mp[N][N];//地图
int dis[N];//存储距离
int vis[N];//标记

int min(int x, int y) {
	return x < y ? x : y;
}
int prime(int s) //传进起始点
{

	for (int i = 0; i < n; i++) {
		dis[i] = inf;
		vis[i] = 0;
	}
	dis[s] = 0;
	int res = 0;
	while (true) {
		int v = -1;
		for (int i = 0; i < n; i++) if (!vis[i] && (v == -1 || dis[i] < dis[v])) v = i;;
		if (v == -1) break;
		vis[v] = true;
		res += dis[v];
		for (int i = 0; i < n; i++) {
			dis[i] = min(dis[i], mp[v][i]);
		}
	}return res;
}

void work() {
	while (cin >> n) {
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++) { cin >> mp[i][j]; if (!mp[i][j]) mp[i][j] = inf; }
		int num = prime(0);
		cout << num << endl;
	}
}
int main() {
	work();
	system("pause");
	return 0;
}
//法二
void prim(){
	int i,j,d[MAXV],vis[MAXV],mi,v;
	for(i=1;i<=n;i++){
		d[i]=map[1][i];
		vis[i]=0;
	}
	for(i=1;i<=n;i++){
		mi=inf;
		for(j=1;j<=n;j++)
			if(!vis[j] && d[j]<mi){
				mi=d[j];
				v=j;
			}
		vis[v]=1;
		for(j=1;j<=n;j++)
			if(!vis[j] && d[j]>map[v][j])
				d[j]=map[v][j];
	}
	for(d[0]=0,i=1;i<=n;i++) d[0]+=d[i];
 
	printf("%d\n",d[0]);
｝
// 法三
const int inf = 0x3f3f3f3f;
const int N = 30;

int n; //节点数
int mp[N][N];//地图
int dis[N];//存储距离
int vis[N];//标记

int prime(int s) //传进起始点
{
    int sum = 0;  //权值总和

    for(int i = 0;i < n;i ++)  //初始化起始点到各点的距离
        dis[i] = mp[s][i];

    vis[s] = 1;      

    for(int i = 1;i <= n - 1;i ++)
    {
        //  n - 1次迭代
        int minn = inf;
        int p;
        for(int j = 0;j < n;j ++)       //找到距离最小的点
        {
            if(!vis[j] && dis[j] < minn)
                minn = dis[j], p = j;
        }

        vis[p] = 1;    

        sum += minn;        //加上边权值

        for(int j = 0;j < n;j ++)  //松弛操作
        {
            if(!vis[j] && dis[j] > mp[p][j])
                dis[j] = mp[p][j];
        }
    }
    return sum;
}

memset 的使用

#include<cstring>
//memset赋值时以 单字节赋值
//memset使用时要千万小心，在给char以外的数组赋值时，只能初始化为0或者-1。

char a[10];
int num[10];
memset(a,'A',sizeof(a));//是可以的  效果是全部复制为‘A’
memset(num,0,sizeof(num));//也可以
memset(num,1,sizeof(num));//不可以
李！
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
0020算法笔记——【动态规划】最优二叉搜索树问题 - liufeng_king的专栏 - 博客频道 - CSDN1
08-03
在实际编程实现中，可以使用记忆化搜索或者自底向上的动态规划方法，避免重复计算子问题。 总之，最优二叉搜索树问题是寻找一种平衡二叉搜索树结构，使得在给定的存取概率分布下，搜索操作的平均成本最小。这个问题...
算法练习——记忆化算法
qq_51855957的博客
12-30 457
记忆化搜索 递归的过程中有许多的结果是被反复计算的，这样会大大降低算法的执行效率。 将已经计算出来的结果保存起来，计算用到的时候直接取出结果，避免重复运算，因此极大的提高了算法的效率。 力扣509斐波那契数 F(n)=F(n−1)+F(n−2) class Solution { public int fib(int n) { if (n == 0) return 0; if (n == 1) return 1; int[] memory = n
算法数据结构——记忆化搜索（Memoization Search）算法超详细总结加应用案例讲解
白话机器学习
06-08 8564
记忆化搜索（Memoization Search）：是一种通过存储已经遍历过的状态信息，从而避免对同一状态重复遍历的搜索算法。记忆化搜索是动态规划的一种实现方式。在记忆化搜索中，当算法需要计算某个子问题的结果时，它首先检查是否已经计算过该问题。如果已经计算过，则直接返回已经存储的结果；否则，计算该问题，并将结果存储下来以备将来使用。举个例子，比如「斐波那契数列」的定义是：$f(0) = 0, f(1) = 1, f(n) = f(n - 1) + f(n - 2)$。
如何描述、记忆算法？
binling的专栏
08-12 1451
循环的是按什么循环，循环变量代表的意义，
算法沉淀——记忆化搜索（leetcode真题剖析）
立志做一个高产且细节博主
02-24 1666
记忆化搜索算法（Memoization）是一种通过存储已经计算过的结果来避免重复计算的优化技术，通常应用于递归算法中。这种技术旨在提高算法的效率，减少重复计算，特别是对于具有重叠子问题的问题。
记忆算法
auauau
05-26 251
[code="java"] package test; public class Word { private String word; private int level; private int no; public String getWord() { return word; } public void setWord(String word...
算法套路学习笔记（csdn）————程序.pdf
12-05
本文主要围绕算法学习笔记展开，包括基础语法、Java String 常用方法以及动态规划解题套路，特别关注了哈希表的使用和斐波那契数列的动态规划解决方案。 1. 哈希表（unordered_map） 哈希表在C++中以`unordered_map...
[网盘]算法笔记-上机训练实战指南-胡凡 完整版
03-21
根据提供的文件信息，我们可以推断出这是一本关于算法学习的书籍资料——《算法笔记-上机训练实战指南》，作者为胡凡。该书共有442页，内容全面覆盖了算法的基础理论与实践操作，适合希望提升算法能力的学习者使用。...
自写线代笔记——李永乐.pdf
06-26
标题《自写线代笔记——李永乐.pdf》暗示了该文档是李永乐老师所讲授线性代数课程的个人笔记。李永乐作为考研教育界的知名讲师，其课程在考研学生中颇具影响力。这份笔记可能涵盖了他课程中的核心概念和讲解内容，供...
秋招算法笔记集合（深度学习机器学习数据结构等）.zip
09-06
《秋招算法笔记集合》是一份综合性的学习资源，涵盖了深度学习、机器学习以及数据结构等多个领域的精华内容。这份资料的目的是帮助准备秋季招聘的求职者们系统地复习和掌握必要的算法知识，以应对面试中的各类挑战。...
智能小车循迹记忆算法
11-07
该文档介绍的是智能小车迷宫地图路径循迹算法，实现智能小车在迷宫中的自主导航
[Algorithm][回溯][记忆化搜索][斐波那契数][不同路径] + 记忆化搜索原理 详细讲解
最新发布
SnowK博客
05-20 3992
[Algorithm][回溯][记忆化搜索][斐波那契数][不同路径] + 记忆化搜索原理 详细讲解
佛学“五蕴”与层级时空记忆模型算法（HTM）过程上是多么巧合？
冯喆--AI工匠
08-22 2113
佛学“五蕴”与层级时空记忆模型算法（HTM）过程上是多么巧合？ 一、佛学“五蕴” 我们读佛经时，经常遇到“五蕴”一词，如《般若波罗蜜多心经》：“观自在菩萨，行深般若波罗蜜多时，照见“五蕴”皆空。 经文：以观舍利子为例，受想行识的相同道理论证 （一）色蕴：即物质的积聚。色蕴包含内色与外色。内色就是：眼、耳、鼻、舌、身－－五根：我们所依靠生活的根身（身躯）；外色就是：色、声、香、味、触－－...
5.基于记忆的推荐算法（memory-based model）
tanyanzimo的博客
07-31 1345
http://m.blog.csdn.net/blog/kevin7658/23744641
记忆方法
wutieliu的博客
05-09 443
从一本书上学到的，该书作者在45岁时，第一次参加日本记忆大赛就获得冠军 1.建立联系 把两个毫不相关的物品强行建立联系，例如：鼠标，和书籍 我们可以通过想像，把两个物品关联起来 鼠标联想到老鼠，书本还是书本 我们可以编这样一个故事：老鼠在啃书。是不是突然形象生动了 2.提高专住度 大脑一旦认为这个东西很重要，我们就会记忆的很清楚.有些人边听音乐，边吃东西，边学习工作的，大脑认为学习和工作不重要...
算法与数据结构核心套路
KeaLoo
11-10 591
目录数据结构的存储方式 数据结构的存储方式 数据结构的底层存储方式只有两种：数组（顺序存储）和链表（链式存储） 分析问题用递归思想：自顶向下，从抽象到具体 “队列”、“栈”，既可以使用链表实现，也可以使用数组实现。用数组实现，要处理扩容和缩容的问题，用链表实现，没有这个问题，但是需要更多的内存空间存储节点指针。 “图”，邻接表就是链表，领接矩阵就是二维数组。用邻接矩阵判断连通性很迅速，并可以进行矩阵运算解决一些问题，但是如果图比较稀疏则很耗费空间。邻接表比较节省空间，但是操作效率比不上邻接矩阵。 “哈
在学习算法的时候的一些学习笔记
赵星汉同学的博客
02-06 893
算法设计 数据结构 前边的常规数据结构 树 树 二叉树 堆 图 蛮力法 什么叫蛮力法 冒泡排序 递归与分治法 树与图中的一些递归问题 二叉树的遍历 分治法的基本思想 动态规划法 基本思想 贪心算法 基本思想 可解决的问题 回溯与分支限界 基本思想 状态空间 状态空间树 迭代改进算法 计算复杂性与NP理论 近似算法 参数化算法 随机算法 随机算法的含义 设计的一般
动态规划算法时间复杂度分析——西安交通大学作业
动态规划算法的核心在于将复杂问题分解为一系列子问题，通过构建表格或记忆化搜索来避免重复计算，从而提高效率。然而，选择合适的记忆化策略和理解问题的最优子结构是关键，这在实际编程和问题解决中需要深入理解和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值