算法模板总结

已于 2022-06-06 19:09:21 修改
阅读量432 收藏 4
点赞数
分类专栏： 算法 文章标签： 程序设计 算法
于 2020-12-18 20:54:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shn111/article/details/111396049
版权

（小菜鸡的第一篇博客保存了一些算法的模板+例题，以防用到的时候找不到）
博客里面都是一些最最最基本的模板，大佬请自动忽略。。。。

一、BFS

//#include<bits/stdc++.h>
#include<iostream>
#include<vector>
#include<queue>
const int maxx = 205;
using namespace std;
int n, m;
int vis[maxx][maxx];
int dis[maxx][maxx];
int loc[4][4] = { {-1,0},{1,0},{0,1},{0,-1} };
char s[maxx][maxx];
int ans;
void bfs(int ss,int sd)
{
	//pair<int,int> p;
	//p.first 第一个元素 p.second 第二个元素
	queue<pair<int, int>> q;
	q.push(make_pair(ss, sd));
	vis[ss][sd] = 1;
	while (!q.empty())
	{
		int l = q.front().first;
		int r = q.front().second;
		q.pop();
		for (int i = 0; i < 4; i++)
		{
			int u = l + loc[i][0];
			int v = r + loc[i][1];
			if (s[u][v] != '#' && u <= n && u > 0 && v <= m && v > 0&&vis[u][v]==0)
			{
				dis[u][v] = dis[l][r] + 1;
				if (s[u][v] == 'x')
					dis[u][v]++;
				vis[u][v] = 1;
				q.push(make_pair(u, v));
				if (s[u][v] == 'r'&&dis[u][v]<ans)
					ans=dis[u][v];
			}
		}
	}
}

int main()
{
	ios::sync_with_stdio(0);
	int ss, sd;
	while (cin >> n >> m)
	{
		memset(vis, 0, sizeof vis);
		memset(dis, 0, sizeof dis);
		ans = 99999;
		for (int i = 1; i <= n; i++)
		{
			cin >> (s[i] + 1);
			for (int j = 1; j <= m; j++)
			{
				if (s[i][j] == 'a')
				{
					ss = i;
					sd = j;
				}
			}	
		}
		bfs(ss, sd);	
		if (ans==99999)
		{
			cout << "Poor ANGEL has to stay in the prison all his life.\n";
     	}
		else
			cout <<ans << endl;
	}
}

二、DFS

void dfs()
{
	if (到达终点状态)
	{
		...
			return;
	}
	if (越界或者是不合法状态)
		return;
	if (特殊状态)
		return;
	for (扩展方式)
	{
		if (扩展方式所到达状态合法)
		{
			修改操作;//根据题意来添加标记
			dfs();
			还原标记;
			//是否还原标记根据题意
			//如果加上(还原标记)就是回溯法
		}
	}
}

三、DP

//动态规划dp
//过河卒 洛谷P1002
#include<iostream>
using namespace std;
int a[25][25] = {0};
int dp[25][25] = {0};
int fx[8] = { 2,1,-1,-2,-2,-1,1,2 };
int fy[8] = { 1,2,2,1,-1,-2,-2,-1 };
int n, m, p, q;

void init()
{
	a[p][q] = 1;
	for (int i = 0; i <= 7; i++)
	{
		if (p + fx[i] >= 0 && p + fx[i] <= n  && q + fy[i] >= 0 && q + fy[i] <= m )
		{
			a[p + fx[i]][q + fy[i]] = 1;
		}
	}
}

void dpp()
{
	dp[0][0] = 0;
	for (int j = 1; j<=m; j++)
	{
		if (a[0][j] != 1)
			dp[0][j] = 1;
		else
			break;
	}
	for (int i = 1; i<=n; i++)
	{
		if (a[i][0] != 1)
			dp[i][0] = 1;
		else
			break;
	}
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
		{
			if (a[i][j] == 1)
				dp[i][j] == 0;
			else
				dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
		}
	}
}

int main()
{
	cin >> n >> m >> p >> q;
	init();
	dpp();
	cout << dp[n][m];
}

四、KMP

#include<iostream>
using namespace std;

void makeNext(const char P[], int next[])
{
	int q, k;//q是当前要计算第q个字符的next值，k是对应的next值
	int m = strlen(P);
	next[0] = 0;
	for (q = 1, k = 0; q < m; q++)
	{
		while (k > 0 && P[k] != P[q])
		{
			k = next[k - 1];
		}
		if (P[q] == P[k])
		{
			k++;
		}
		next[q] = k;
	}
}

int  kmp(const char T[], const char P[], int next[])
{
	int n, m;
	n = strlen(T);
	m = strlen(P);
	makeNext(P, next);
	int i = 0;
	int j = 0;
	while (i < n && j < m)
	{
		if ( j==0||T[i] == P[j])
		{
			i++;
			j++;
		}
		else
		{
			j = next[j-1];
		}
	}
	if (j == m)
		return  i - m + 1;
	else
		return -1;
	
}
int main()
{
	int next[100] = { 0 };
	char T[] = "abababababc";
	char P[] = "abc";
    cout<<kmp(T, P, next);
    return 0;
}

五、素数筛

#include<iostream>
using namespace std;
bool str[100010]; 					//开始定义一个全局变量数组 
void prime()						//这个函数可以将1~100010内的所有素数都找出来，所以在main()函数开头执行一遍就行了 
{
	str[1] = 1;						//希望读者能将这一块跟第二种方法进行一个比较，便于理解 
	for (int i = 2; i * i <= 100010; i++)
	{
		if (!str[i])
		{
			for (int j = i * i; j <= 100010; j += i)
				str[j] = 1;
		}
	}
}
int main()
{
	prime(); 						 //执行程序开始的打表操作 
	int n;
	while (cin >> n)
	{
		if (str[n]) cout << "不是素数！" << endl; 	//判断是否为素数 
		else cout << "是素数！" << endl;
	}
	return 0;
}

六、拓扑排序

#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;
const int MX = 500 + 10;
int N, M;
vector<int>G[MX];//可约当做声明了一个二维数组
int indegree[MX];//记录各定点入度的数组
queue<int>q;

//初始化，将AOV网存储到数据结构中
void init()
{
	for (int i = 1; i <= M; i++)//M是关系数
	{
		int node1, node2;
		cin >> node1 >> node2;
		G[node1].push_back(node2);
		//在G[node1]的尾部加入数据node2，表示node2是node1的直接后继
		indegree[node2]++;//node2的入度加一
	}
}

int topo_sort()
{
	for (int i = 1; i <= N; i++)
		if (indegree[i] == 0)
			q.push(i);//若i的入度为0，则将i入队
	int cnt = 0;
	while (!q.empty())
	{
		cnt++;
		int tmp = q.front();//记录当前队头元素
		q.pop();
		for (int i = 0; i < G[tmp].size(); i++)//遍历当前队头元素tmp的所有直接后继
		{
			int node = G[tmp][i];//node记录tmp的第i个直接后继（i从0开始）
			indegree[node]--;
			if (indegree[node] == 0)
				q.push(node);//入度为0，则入队
		}
		if (!q.empty())
			cout << tmp << " ";
		else
			cout << tmp;//使最后一个输出数据后面无空格
	}
	if (cnt < N)
		return -1;//说明存在点没有入队，即成环。
}

七、字典树

include<iostream>
#include<cstring>
using namespace std;
const int MAXN = 26;
struct Trie
{
    // 代表当前节点可以延伸出的边，数量可变
    Trie* Next[MAXN];
    // 标记当前节点是否是保存信息的结尾，也可以代表前缀个数
    int Flag;
    Trie()
    {
        // 初始化以该信息为前缀的信息个数
        Flag = 1;
        memset(Next, NULL, sizeof(Next));
    }
};

Trie* root = new Trie();

void Insert(string s)
{
	int len = s.length();
	int id;
    Trie* p = root;
    Trie* q;
    //将s的每一个字符插入trie树
	for (int i = 0; i < len; i++)
	{
        id = s[i] - 'a';
        //如果没有边，则新建一个trie节点，产生一条边，用以代表该字符。
        if (p->Next[id] == NULL)
        {
            q = new Trie();
            p->Next[id] = q;
            p = p->Next[id];
        }
        //如果存在边，则沿着该边走。
        else
        {
            p = p->Next[id];
            //累加以该信息为前缀的信息个数
            ++(p->Flag);
        }
	}
}

int Query(const char* str)
{
    int len = strlen(str);
    Trie* p = root;
    //在trie树上顺序搜索str的每一个字符
    for (int i = 0; i < len; ++i)
    {
        int id = str[i] - 'a';
        p = p->Next[id];
        if (p == NULL)
            return 0;
    }
    return p->Flag;
}

void Free(Trie* T)
{
    if (T == NULL)
        return;
    //释放trie树的每一个节点占用的内存
    for (int i = 0; i < MAXN; ++i)
    {
       if(T->Next[i])
        Free(T->Next[i]);
    }
    delete(T);
}

int main()
{
    const char* word[4] = {"banana","band","bee","absolute"};
    const char* fore[4] = { "ba","b","band","abc" };
    for (int i = 0; i < 4; i++)
    {
        Insert(word[i]);
    }

    for (int i = 0; i < 4; i++)
    {
        cout << Query(fore[i]) << endl;
    }
}

八、最短路径

//最短路径
// 1.floyed  时间复杂度O(n三次方)
/*void floyed()
{
	for (int i = 1; i <= n; i++)//通过中间顶点进行中转
	{
		for (int k = 1; k <= n; k++)//k为所有的起点
		{
			for (int j = 1; j <= n; j++)//j为终点
			{
				m[k][j] = min(m[k][j], m[k][i] + m[i][j]);
			}
		}
	}
	return;
}*/
// 2.Dijkstra 时间复杂度O(n平方)
void Dijkstra()
{
	for (int i = 1; i <= n - 1; i++)
	{
		//找到离1号顶点最近的顶点
		min1 = inf;//inf为无穷大
		for (int j = 1; j <= n; j++)
		{
			if (book[j] == 0 && dis[j] < min1)//找到距离起点最近的点
			{
				min1 = dis[j];//更新离当前顶点最近的顶点
				u = j;
			}
		}

		book[u] = 1;//标记u这个点进入S集合
		for (int v = 1; v <= n; v++)
		{
			if (e[u][v] < inf)//u,v之间想通
			{
				if (dis[v] > e[u][v] + dis[u])//松弛
				{
					dis[v] = dis[u] + e[u][v];//更新最短的路径
				}
			}
		}
	}
}

九、快速排序

void quickSort(int s[], int l, int r)
{
    int mid = s[(l + r) / 2];
    int i = l, j = r;
    do
    {
        while (s[i] < mid)
            i++;
        while (s[j] > mid)
            j--;
        if (i <= j)
        {
            swap(s[i], s[j]);
            i++;
            j--;
        }
    } while (i <= j);
    if (l < j)
        quickSort(s, l, j);
    if (i < r)
        quickSort(s, i, r);
}

十、背包

//01背包
#include <bits/stdc++.h>
using namespace std;
int n,v,w,c,dp[1010];//dp[i]表示装入物品的质量为i时能获得的最大价值
int main()
{
    cin>>v>>n;//v为背包容量，n为物品数量
    for(int i=1;i<=n;i++)
    {
        cin>>w>>c;//w为每个物品重量，c为每个物品价值
        for(int j=v;j>=w;j--)//背包容量从大到小遍历
        dp[j]=max(dp[j],dp[j-w]+c);//选择不放入背包dp[j]还是放入背包dp[j-w]+c，更新为最大的dp[j]
    }
    printf("%d\n",dp[v]);//装入物品的质量为v时能获得的最大价值
    return 0;
}
//完全背包
#include <bits/stdc++.h>
using namespace std;
int n,v,w,c,dp[100010];
int main()
{
    cin>>v>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>w>>c;
        for(int j=w;j<=v;j++)//背包容量从小到大遍历，这里与01背包循环顺序相反！
        dp[j]=max(dp[j],dp[j-w]+c);
    }
    printf("%d\n",dp[v]);
    return 0;
}
polarday.
关注
专栏目录
算法模板整理
Y.W.jian的博客
07-21 1796
---------------------转载请注明出处--------------------------- ---------------------转载请注明出处--------------------------- ---------------------转载请注明出处--------------------------- 文章目录二叉树总模板二分搜索树模板单调栈基础模板循环数组模板单调队列二分查找二分查找模板基本二分查找左侧边界二分查找右侧边界二分查找双指针快慢指针左右指针滑动窗滑动窗模板回溯算
【C/C++】二分查找算法模板总结（适用于大多数情况）
qq_44794039的博客
02-24 879
二分查找算法模板 【二分条件】 条件： 单调、有序 时间复杂度： O(logn) 【伪代码模板】 l = -1, r = n //注意l和r一开始要在区间外 也就是二分区间为[0, n-1] while(l + 1 != r){ m = (l + r)>>1; //m∈[0, n) if(check()){ l = m; } else{ r = m; } return l or r; //根据实际情况选择返回l或者r } 【注意细节】 为什么l和r一开始要在区间外面?
数学算法模板总结
YJSheep
04-01 993
数学算法模板总结 线性筛素数+逆元+BSGS+欧拉函数
基础算法模板总结
openallzzz
12-12 1733
面试和笔试所考察的基础算法模板汇总+附加相关练习 (C++实现) 一共六大章，分别是基础算法、数据结构、搜索与图论、数学知识、动态规划、贪心与杂讲
算法模板总结（持续更新
寅贝勒的博客
03-19 3917
二分查找 // 二分查找的最基础和最基本的形式 int binarySearch(int[] nums, int target){ if(nums == null || nums.length == 0) return -1; int left = 0, right = nums.length - 1; while(left <= right){ // Prevent (left + right) overflow int mid = left + (right
常用算法模板总结1
weixin_62224014的博客
03-08 720
朴素版Dijkstra算法 核心思路： 1.循环n次，每次找到到起点距离最小且不在已确定集合中的的点 2.将找到的点放入集合中 3.用找到的点来更新其他所有未在集合之中的点 代码： #include <iostream> #include <cstring> #include <algorithm> using namespace std; int n,m; const int N = 510,M=1e5+10; int g[N][N]; int dist.
部分常见算法模板总结
01-09
本知识点总结了部分常见的算法模板，包括高精计算、快速幂、背包问题、区间DP、并查集、树状结构等。下面将详细介绍这些算法模板中的核心知识点。 高精计算 高精计算是指超出标准数据类型（如int和long long）能够...
常用算法模板_C++.zip
04-27
常用算法模板_C++.zip AC自动机，Dijkstra，Floyd，GCD，KMP，KMP扩展，Kruskal，LCM，LCS，LIS，Prim，SPFA，埃氏筛，背包，并查集，多边形面积，二分搜索，高精度加法，高精度阶乘，级角排序，进制转换，快速幂，...
【LeetCode】算法模板与学习方法小结（不断更新中）
HeavenDan的博客
09-11 1805
一、代码模板 1、递归 // Java public void recur(int level, int param) { // terminator if (level > MAX_LEVEL) { // process result return; } // process current logic process(level, param); // drill down recur( level: level + 1, n
kuangbin的ACM模板（新）_ACM模板_ACM算法总结_
09-29
《kuangbin的ACM模板（新）》是针对ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）竞赛的一份详细算法总结。这份资料旨在帮助参赛者系统地理解和掌握ACM比赛所需的各类核心算法，...
常用算法模板总结--随记
Carroll的博客
10-04 340
辗转相除法 用来求最大公约数 private int gcd(int a, int b) { return b == 0? a: gcd(b, a % b); } while(x % y != 0){ temp = x % y; x = y; y = temp; } ...
一些常用的算法模板总结
qq_45100361的博客
06-04 109
树的层序遍历BFS public static void treeBFS(TreeNode root) { //如果为空直接返回 if (root == null) return; //队列 Queue<TreeNode> queue = new LinkedList<>(); //首先把根节点加入到队列中 queue.add(root); //如果队列不为空就继续循环 while (!queue.isE
常用算法模板总结--数学
Carroll的博客
04-27 184
文章目录试除法判定质数试除法分解质因数朴素筛法求素数埃式筛法求素数线性筛法求素数试除法求所有约数约数个数 和 约数之和欧几里得算法(辗转相除法)快速幂 试除法判定质数 boolean is_prime(int x) { if (x < 2) { return false; } for (int i = 2; i <= x / i; i ++ ) { if (x % i == 0) {
算法入门经典模板总结
Sillver_的博客
11-10 1362
第二章——算法设计优化 快速选择问题 中位数 POJ2388 思路分析：nth_element 函数的使用。 nth_element 用法： nth_element(a, a+k, a+n); nth_element 时间复杂度： O(N)。 nth_element 结果：将第 k 个元素放在整个数组中的第 k 个位置，并且左侧的元素都比这个数字小，但是不保证有序，右侧都比这个元素大，同样不保证有序。 nth_element详解 #include <iostream> #include &l
常用算法模板小总结
xoxcu的博客
06-30 202
判断是否是闰年 bool isleapYear(int y){ return (y%4==0&&y%100!=0)||(y%400==0); } 判断是否是素数 int is_prime(int n) { if(n<=1) return 0; int m=floor(sqrt(n)+0.5); for(int i=2;i<=m;i++) if(n%i==0) return 0; return 1; } 埃拉托尼斯筛法 void Prime() { for
常用算法模板整理
DaDaguai001的博客
03-27 234
gcd
算法模板
Roar__的博客
03-27 287
武林秘籍头文件#include&lt;set&gt; #include&lt;cmath&gt; #include&lt;cstring&gt; #include&lt;map&gt; #include&lt;algorithm&gt; #include&lt;map&gt; #include&lt;sstream&gt; #include&lt;iostream&gt; #inc
ACM算法模板总结：大数、搜索、最短路等
这篇文档是一个针对ACM竞赛的算法模板集合，包含了多种常用算法的C/C++实现。它旨在帮助初学者理解和记忆常见问题的解决策略，并提供可复用的代码模板。文档涵盖的算法范围广泛，包括大数操作、二分查找、枚举排列、...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值