算法模板(不定期更新)

已于 2022-04-08 23:23:48 修改
阅读量284 收藏
点赞数 3
分类专栏： 模板 文章标签： c++ 蓝桥杯 深度优先
于 2022-03-05 10:19:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MrJinNEU/article/details/123290297
版权
该博客主要介绍了BFS算法用于寻找图中最短路径并打印路径的方法，同时提供了迪杰斯特拉算法的模板实现。内容包括BFS的基本流程、路径记录和方向判断，以及迪杰斯特拉算法的优化过程，适用于寻找单源最短路径问题。
摘要由CSDN通过智能技术生成

bfs最短路模板

最短路+打印路径+记录方向

#include <bits/stdc++.h>
using namespace std;
// bfs路径打印
// https://blog.csdn.net/ryo_218/article/details/88830082?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1.pc_relevant_paycolumn_v3&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1.pc_relevant_paycolumn_v3&utm_relevant_index=1
int m, n; //长，高
struct node
{
    int x;
    int y;
    string path;
};
char maze[100][100];
bool visit[100][100];
int dirx[4] = {1, 0, 0, -1}; // D<L<R<U
int diry[4] = {0, -1, 1, 0};
char dir[4] = {'D', 'L', 'R', 'U'};
bool judge(int x, int y, int startx, int starty)
{
    if (x == n && y == m)
        return true;
    else
        return false;
}
void bfs(int startx, int starty)
{
    queue<node> q;
    visit[startx][starty] = 1;
    node p;
    p.x = startx, p.y = starty;
    q.push(p);
    while (!q.empty())
    {
        int x = q.front().x;
        int y = q.front().y;
        string way = q.front().path;
        q.pop();
        if (judge(x, y, startx, starty))
        {
            cout << way;
            return;
        }
        for (int i = 0; i < 4; i++)
        {
            int rempx = x + dirx[i];
            int rempy = y + diry[i];
            string rempway = way + dir[i];
            if (maze[rempx][rempy] == '0' && visit[rempx][rempy] == 0 && rempx <= n && rempx > 0 && rempy <= m && rempy > 0)
            {
                // cout<<"1 ";
                //  cout<<rempway<<endl;
                visit[rempx][rempy] = 1;
                node remp;
                remp.x = rempx, remp.y = rempy, remp.path = rempway;
                // cout << rempway << endl;
                q.push(remp);
            }
        }
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> m >> n;
    for (int i = 1; i <= n; i++)
    {
        string remp;
        cin >> remp;
        for (int j = 1; j <= m; j++)
        {
            maze[i][j] = remp[j - 1];
        }
    }
    bfs(1, 1);
    return 0;
}
/* 样例
50 30
01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000
*/

迪杰斯特拉（最短路）

一道模板题：
在这里插入图片描述
大循环是n-1次循环
标号从0开始到n-1
题目没说清楚

#include <bits/stdc++.h>
using namespace std;
#define maxn 100
#define INF 10000
int edge[maxn][maxn];
int path[maxn];
bool visit[maxn];
int main()
{
	int n, s;
	cin >> n >> s;
	for (int i = 0; i < n; i++)
		path[i] = INF;

	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			cin >> edge[i][j];
			if (edge[i][j] == 0)
				edge[i][j] = INF;
		}
	}
	for (int i = 0; i < n; i++)
		edge[i][i] = 0;

	path[s] = 0;
	for (int i = 1; i < n; i++)
	{
		int min1 = -1;
		for (int j = 0; j < n; j++)
		{
			if ((min1 == -1 || path[j] < path[min1]) && visit[j] == false)
			{
				min1 = j;
			}
		}
		visit[min1] = true;

		for (int j = 0; j < n; j++)
		{
			path[j] = min(path[min1] + edge[min1][j], path[j]);
			//			cout<<path[j]<<" ";
		}
		//		cout<<endl;
	}


	for (int i = 0; i < n; i++)
	{
		if (i == s)
			continue;
		if (path[i] == INF)
			cout << -1 << " ";
		else
			cout << path[i] << " ";
	}
	cout << endl;
	return 0;
}

另附有最大公因数，最小公倍数求法

#include <bits/stdc++.h>
using namespace std;
// 传送门：https://blog.csdn.net/qq_36306833/article/details/121872050
// 迪杰斯特拉算法(首次使用紫书模板)
 #define INF 0x3f3f3f3f
int edge[2030][2030];
int path[2030];
bool visit[2030];
int gcd(int x, int y)
{
    if (y == 0)
        return x;
    else
        return gcd(y, x % y);
}
int lcm(int x, int y)
{
    return x / gcd(x, y) * y;
}
int main()
{
    memset(edge, INF, sizeof(edge));
    for (int i = 1; i <= 2021; i++)
        for (int j = i + 1; j <= 2021; j++)
        {
            if (j - i > 21)
                continue;
            int cost = lcm(i, j);
            edge[i][j] = cost;
            edge[j][i] = cost;
        }
    // 算法开始
    memset(visit, 0, sizeof(visit));
    memset(path, INF, sizeof(path));
    path[1] = 0;
    for (int i = 1; i <= 2021; i++)
    {
        int start, min1 = INF;
        for (int j = 1; j <= 2021; j++)
        {
            if (!visit[j] && path[j] <= min1)
            {
                min1 = path[j];
                start = j;
            }
        }
        visit[start] = 1;
        for (int j = 1; j <= 2021; j++)
        {
            path[j] = min(path[j], path[start] + edge[start][j]);
        }
    }
    cout << path[2021];
    return 0;
}

另外附上打印路径方式(加变式)：

#include <bits/stdc++.h>
using namespace std;
// 传送门：https://pintia.cn/problem-sets/994805046380707840/problems/994805073643683840
// 迪杰斯特拉最短路(加变式)+打印路径
#define maxn 600
#define INF 0x3f3f3f3f
int city[maxn];       //每一个城市的救援队
int cost[maxn][maxn]; //维护图
int path[maxn];       //代表从起点到i城市的权值
int pre[maxn];        //记录i城市前驱节点
int num[maxn];        //记录从起点到i城市有最短路有多少种走法
int sum[maxn];        // i城市到起点最短路上能积极的最多救援队
int visit[maxn];      //标记蓝点
int main()
{
    ios::sync_with_stdio(false);
    int n, m, s, d;
    cin >> n >> m >> s >> d;
    memset(cost, INF, sizeof(cost));
    for (int i = 0; i < n; i++)
    {
        cin >> city[i];
        sum[i] = city[i]; //初始化sum数组
        num[i] = 1;       //初始化num数组
        pre[i] = -1;
    }
    for (int i = 1; i <= m; i++)
    {
        int c1, c2, cos;
        cin >> c1 >> c2 >> cos;
        cost[c1][c2] = cost[c2][c1] = cos;
    }
    memset(path, INF, sizeof(path));
    path[s] = 0;
    for (int i = 1; i < n; i++)
    {
        int min1 = INF, start = -1;
        for (int j = 0; j < n; j++)
        {
            if (visit[j] == false && path[j] <= min1)
            {
                start = j;
                min1 = path[j];
            }
        }
        visit[start] = true;
        for (int j = 0; j < n; j++)
        {
            if (path[j] > path[start] + cost[start][j])
            {
                path[j] = path[start] + cost[start][j];
                pre[j] = start; //更新pre前驱
                sum[j] = city[j] + sum[start];
                num[j] = num[start];
            }
            else if (path[j] == path[start] + cost[start][j])
            {
                if (sum[j] < city[j] + sum[start])
                {
                    pre[j] = start;
                    sum[j] = city[j] + sum[start];
                }
                num[j] = num[j] + num[start];
            }
            // path[j] = min(path[start] + cost[start][j], path[j]);
        }
    }
    // cout << "path ";
    // for (int i = 0; i < n; i++)
    //     cout << path[i] << " ";
    // cout << endl;
    // cout << "pre ";
    // for (int i = 0; i < n; i++)
    //     cout << pre[i] << " ";
    // cout << endl;
    // cout << "sum ";
    // for (int i = 0; i < n; i++)
    //     cout << sum[i] << " ";
    // cout << endl;
    // cout << "num ";
    // for (int i = 0; i < n; i++)
    //     cout << num[i] << " ";
    // cout << endl;
    cout << num[d] << " " << sum[d] << endl;
    vector<int> a;
    int end = d;
    while (d != -1)
    {
        a.push_back(d);
        d = pre[d];
    }
    for (int i = a.size() - 1; i >= 0; i--)
    {
        if (i)
            cout << a[i] << " ";
        else
            cout << a[i];
    }

    return 0;
}

弗洛伊德算法

注：假如是普通的最短路寻找，数组的初始化有所不同，要把所有的自回路赋值为0

	for(int i=1;i<=num;i++)
		edge[i][i]=0;

#include <bits/stdc++.h>
using namespace std;
// floyed算法(会超时大概一分钟之后得到答案/捂脸）)
// 传送门：https://blog.csdn.net/qq_36306833/article/details/121872050
// 答案：10266837
int edge[2030][2030];
int gcd(int x, int y)
{
    if (y == 0)
        return x;
    else
        return gcd(y, x % y);
}
int lcm(int x, int y)
{
    return x / gcd(x, y) * y;
}
int main()
{
    memset(edge, 0x3f, sizeof(edge));
    for (int i = 1; i <= 2021; i++)
        for (int j = i + 1; j <= 2021; j++)
        {
            if (j - i > 21)
                continue;
            int cost = lcm(i, j);
            edge[i][j] = cost;
            edge[j][i] = cost;
        }
    for (int k = 1; k <= 2021; k++)
        for (int i = 1; i <= 2021; i++)
            for (int j = 1; j <= 2021; j++)
            {
                edge[i][j] = min(edge[i][k] + edge[k][j], edge[i][j]);
            }
    cout<<edge[1][2021];
    // cout<<lcm(3,5);
    return 0;
}

克鲁斯卡尔算法

原题：繁忙的都市
克鲁斯卡尔+并查集模板

#include <bits/stdc++.h>
using namespace std;
// 传送门：https://www.luogu.com.cn/problem/P2330
// 最小生成树+克鲁斯卡尔算法
#define maxn 10000
#define con 100000
int n, m;
struct node
{
    int start;
    int end;
    int cost;
} edge[con];
int father[maxn];
bool cmp(node a, node b)
{
    return a.cost < b.cost;
}
// int link[maxn];
int find(int a)
{
    if (father[a] == a)
        return a;
    else
        return father[a] = find(father[a]);
}
int num_ans, cost_ans;
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        int remp1, remp2, remp3;
        cin >> remp1 >> remp2 >> remp3;
        edge[i].start = remp1,
        edge[i].end = remp2;
        edge[i].cost = remp3;
    }
    // 好戏登场
    sort(edge + 1, edge + 1 + m, cmp);
    for (int i = 1; i <= n; i++)
    {
        father[i] = i;
        // link[i] = 1;
    }
    int link = 0;
    for (int i = 1; i <= m; i++)
    {
        int s = edge[i].start;
        int e = edge[i].end;
        if (find(s) != find(e))
        {
            link++;
            num_ans++;
            cost_ans = edge[i].cost; //因为数组按照cost值升序，所以最大值一定是最后一个进入mst的路的权值
            int fa1 = find(s);
            int fa2 = find(e);
            father[fa1] = father[fa2];
            // int sum = link[fa1] + link[fa2];
            // link[fa1] = link[fa2] = sum;
            // if (sum == n)
            //     break;
        }
        if (link == n - 1)
            break;
    }
    cout << n - 1 << " " << cost_ans;//每个边一次连两个点，所以个数一定是n-1个
    return 0;
}

拓扑排序

原题： 最长食物链

#include <bits/stdc++.h>
using namespace std;
// 传送门：https://www.luogu.com.cn/problem/P4017
// 题解：https://www.luogu.com.cn/problem/solution/P4017
// 拓扑排序
#define maxn 5000000
#define mod 80112002
int n, m;
vector<int> edge[maxn];
int in[maxn], out[maxn]; //一个是入度，一个是出度
long long ans[maxn];     // ans[i]表示到达第i个结点时，此时拥有的路径总数
queue<int> q;
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        int remp1, remp2;
        cin >> remp1 >> remp2;        // remp2吃remp1
        edge[remp1].push_back(remp2); //被吃掉的后面接捕食者
        in[remp2]++;
        out[remp1]++; //右节点入度+1,左节点出度+1
    }

    for (int i = 1; i <= n; i++)
        if (in[i] == 0)
        {
            q.push(i);
            ans[i] = 1;
        }

    while (!q.empty())
    {
        int front = q.front();
        q.pop();
        for (int i = 0; i < edge[front].size(); i++)
        {
            in[edge[front][i]]--;
            ans[edge[front][i]] = (ans[edge[front][i]] + ans[front]) % mod;
            if (in[edge[front][i]] == 0)
            {
                q.push(edge[front][i]);
            }
        }
    }
    long long ans1 = 0;
    for (int i = 1; i <= n; i++)
    {
        if (out[i] == 0) //只要出度为0，说明是食物链终点（切不可用sort快排取最大！因为出度为0的点不止一个！）
            ans1 += ans[i];
    }
    cout << ans1 % mod;
    return 0;
}

素数筛

埃式筛：

#include <bits/stdc++.h>
using namespace std;
bool prime[1000];
int main()
{
    int num;
    cin>>num;
    for(int i=2;i<=num;i++)
    {
        for(int j=i*i;j<=num;j+=i)//这里有一个小优化，j 从 i * i 而不是从 i + i开始，因为 i*(2~ i-1)在 2~i-1时都已经被筛去，所以从i * i开始。
        prime[j]=1;
    }
    for(int i=2;i<=num;i++)
    {
        if(!prime[i])
        cout<<i<<endl;
    }

    return 0;
}

欧拉筛

#include <bits/stdc++.h>
using namespace std;
//欧拉筛 时间复杂度O(n)
bool judge[1000000] = {1, 1}; // 0，1先筛去
int prime[100000];
int main()
{
    int num;
    cin >> num;
    int count = 0;
    for (int i = 2; i <= num; i++)
    {
        if (!judge[i])
            prime[count++] = i;
        for (int j = 0; j < num; j++)
        {
            if (prime[j] * i > num)
                break; //如果此时已经大于边界，后面的素数肯定也大于边界，所以直接break
            judge[prime[j] * i] = 1;
            if (i % prime[j] == 0)
                break;
// 对于 i%prime[j] == 0 就break的解释 ：当 i是prime[j]的倍数时，i = kprime[j]，如果继续运算 j+1，i * prime[j+1] = prime[j] * k prime[j+1]，这里prime[j]是最小的素因子，当i = k * prime[j+1]时会重复，所以才跳出循环。
// 举个例子 ：i = 8 ，j = 1，prime[j] = 2，如果不跳出循环，prime[j+1] = 3，8 * 3 = 2 * 4 * 3 = 2 * 12，在i = 12时会计算。因为欧拉筛法的原理便是通过最小素因子来消除。
        }
    }
    for(int i=0;i<count;i++)
    cout<<prime[i]<<endl;
    return 0;
}

快速幂

#include <iostream>
using namespace std;
// 给定三个正整数A，B和C，求A ^B  mod C的结果
long long fastpower(long long a, long long b, long long c)
{
	a %= c;
	long long ans = 1;
	while (b)
	{
		a %= c;
		if (b & 1)
			ans = (ans*a) % c;
		b = b / 2;
		a = (a*a)%c;
	}
	return ans;
}
int main()
{
	long long a, b, c;
	cin >> a >> b >> c;
	cout << fastpower(a, b, c) << endl;
	return 0;
}

string查找子串

#include <bits/stdc++.h>
using namespace std;
int main()
{
	string tar;
	cin>>tar;
	string remp;
	cin>>remp;
	if(tar.find(remp)!=string::npos)
	{
		cout<<"YES";
	}
	else
	{
		cout<<"NO";
	}
	
	return 0;
}
蜡笔小金QAQ
关注
专栏目录
java opencv 模板匹配算法_浅谈opencv模板匹配算法原理
weixin_31263231的博客
02-24 621
1、什么是模板匹配简单来说模板匹配就是通过现有的模板去与图片进行比较找出图中所匹配的图像例如网红脸傻傻分不清，可以用模板匹配来特定的网红，如见下图。检测的图片模板opencv官网对模板匹配的解释是：模板匹配是一种用于在较大图像中搜索和查找模板图像位置的方法。为此，OpenCV带有一个函数cv2.matchTemplate()。它只是将模板图​​像滑动到输入图像上(就像在2D卷积中一样)，然后在模板...
落实算法安全主体责任基本情况（模板）
08-18
最后，所有这些制度和规定应当形成书面文件，并定期更新和完善，以便于企业内部管理和外部监管。附件部分应包含现行的规章制度，以便相关部门和人员查阅执行。 总的来说，落实算法安全的主体责任不仅是法律法规的...
学习记录：C++常用模板（不定期持续更新）
TaopiTTT的博客
11-30 2295
望大佬指正Orz
图论模板，随缘不定期更新
Ninght
01-06 1756
图论模板，随缘不定期更新网络流最大流dinic（更新于2021/1/6）hlpp（更新于2021/1/6）最小费用最大流（更新于2021/1/6）无源汇有上下界可行流（更新于2021/1/6）有源汇上下界最大流（更新于2021/1/6）最短路径dijkstra（更新于2021/1/6）spfa（更新于2021/1/6）最小生成树kruskal（更新于2021/1/6）prime（更新于2021/1/6）欧拉通路与欧拉回路并查集（更新于2021/1/6）判断存在欧拉回路（更新于2021/1/6）寻找欧拉路径（
算法核心思想总结及模板（不定期更新）
mr_zj_的博客
02-18 1033
写这篇博客的目的： 加强对算法的理解和概括 备忘 快排（divide-and-conquer）核心思想: 　　每一次划分将小于或等于pivot element（下面第二张图中 xx）的元素依次放在前面，则大于xx的元素就自动到后面一部分了，然后再把xx放到两部分中间（此时xx已排好序，归位），然后对左右两部分递归调用。Update：2017/2/18 筛法求素数核心思想: 　　把合数筛掉。
前缀树算法模板秒杀 5 道算法题
fdl123456的博客
01-20 1647
后台回复进群一起刷力扣点击卡片可搜索关键词????读完本文，可以去力扣解决如下题目：208. 实现 Trie (前缀树)（Medium）1804. 实现 Trie （前缀树） II（Medium...
算法笔记(个人用)(不定期更新)
cuber-lotus的博客
03-23 2787
文章目录前言说明Note文档编辑相关语言特性相关 (C/C++)输出数组最后一个元素后面无空格二分查找函数rand() 范围算法相关排序区间求和题单基础数学素数素数判断素数筛朴素筛选 (埃式筛)朴素筛选优化线性筛 (欧拉筛)闰年判断蔡勒（Zeller）公式GCD10转R进制卡特兰数完美数分解因数欧几里得-欧拉定理数根[1~n] 中完全平方数的个数计算Π pia二分查找顺序序列找唯一值逼近类二分容斥原理位运算整形存储大小intlong long`__builtin_函数`取模自动取模工具类除法取模判断奇偶统计
ChatGPT技术原理解析：从RL之PPO算法、RLHF到GPT4、instructGPT
热门推荐
结构之法 算法之道
01-15 19万+
本篇ChatGPT笔记会全力做到，通俗易懂且循序渐进(尽最大努力让每一个初学者哪怕是文科生都能没有障碍的读懂每一字一句、每一个概念、每一个公式) 一方面，对于想了解ChatGPT背后原理和如何发展而来的，逐一阐述从GPT/GPT2/GPT3到强化学习、PPO算法，最后再到instructGPT、ChatGPT、SeqGAN 且本文之前，99%的文章都不会把PPO算法从头推到尾，本文会把PPO从零推到尾，按照“RL-策略梯度-重要性采样(重要性权重)-TRPO(增加信任区域和KL散度约束)-PPO”的顺序逐步
遗传算法（Genetic Algorithm）详解与实现
盼小辉丶的博客
08-13 1797
在遗传算法 (Genetic Algorithms, GA) 中，使用选择、交叉、突变和适应度来模拟生物减数分裂或繁殖的基本操作。适应度是衡量个体优劣的指标，可以用于量化模拟个体成功解决给定问题的能力。通过修改遗传算法超参数，如种群大小、世代数、交叉率和突变率等超参数，能够调整和修改进化进程。在本节中，我们介绍了遗传算法基本概念及算法流程，并使用 Python 实现遗传算法解决 OneMax 问题。
抽象类、模板方法模式
daqi1983的博客
03-01 1299
在Java中abstract是抽象的意思，如果一个类中的某个方法的具体实现不能确定，就可以申明成abstract修饰的抽象方法（不能写方法体了），这个类必须用abstract修饰，被称为抽象类。
百度算法大全：更新至2121年
06-23 1217
百度算法 百度搜索引擎作为国内搜索引擎中的中流砥柱，为数亿网民常用的生活工作搜索工具，其流量十分可观，蕴含着巨大的流量与商机资源，备受千万企业的青睐。而网站在百度搜索引擎中的自然排名，对于网站流量的获取起着决定性的作用，便决定了网站存在的价值和意义。那么，做好SEO网站优化对于网站运营必不可少。百度搜索引擎为提高访客浏览自身抓取数据的体验度，保护用户的利益与隐私，也保障网站排名公平的前提下，百度算法应运而生。了解清楚百度算法规则，根据百度算法来运营自己的网站，做好SEO工作，才能让自己的网站在搜索排名中崭
落实算法安全主体责任基本情况.docx 已通过审核
04-19
- 成立专门的算法审查团队，定期对算法进行审查与评估。 - 公开透明地发布评估结果与改进措施，接受公众监督。 **2.2 算法安全监测制度** - 建立长效的算法安全监测机制，包括信息安全监测、数据安全监测、用户...
机器视觉平台-算法接入规范说明文档
03-16
开发者可以定期查询任务的状态，以了解分析进度。 - **任务ID**: 同样需要提供任务的唯一标识符。 - **状态**: 返回当前任务的状态，如“正在处理”、“已完成”等。 **3.4 算法分析任务状态回调** 为了实现更高...
leetcode下载-Resource:高质量资源收藏，不定期更新。(ThecollectionofHighqualityresource.)
06-29
收集的一些优质的资源，不定期更新，欢迎拍砖。 1. 猿奋 编程语言 GoLang 算法 网络安全 计算机网络 数学 英语 机器学习 各种命令 架构 面试 软件和技能 软件 技能 2. 电子书 IT技术 非IT [Library Genesis--电子书...
常见算法介绍、算法刷题（含解析与代码）、笔试面试算法题文档
07-03
- **Codeforces**：定期举办算法和编程比赛，挑战性和趣味性强。 ### 笔试面试算法题 - **常见问题**：如数组、链表、树、图的遍历和操作。 - **高频题目**：动态规划问题、字符串处理、递归和回溯算法。 ### ...
使用socket编程来实现一个简单的C/S模型（TCP协议）
最新发布
caiji0169的博客
10-02 1025
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 651
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 420
【代码】求n的阶乘的相反数（c语言）
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 392
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
ACM竞赛模板：算法与数据结构的融合
他还表示，原稿在他的个人博客上，他会定期更新模板，并欢迎大家提出问题和建议，甚至欢迎贡献代码来优化模板。 模板的分类是一个关键点，作者意识到算法和数据结构之间的紧密关系，但为了便于学习，他还是进行了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值