算法课复习 -- 优先队列、最短路

最新推荐文章于 2024-10-07 18:15:04 发布
原创 最新推荐文章于 2024-10-07 18:15:04 发布 · 221 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#图论 #优先队列 #最短路 #负环

本文解析了多个经典算法问题，包括Huffman编码优化的木头锯割问题，Bellman-Ford算法解决的负权边和负环检测问题，以及优先队列应用于任务调度的最短时间问题。覆盖了数据结构与算法的深入应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

POJ #3253 : Fence Repair

传送门：http://poj.org/problem?id=3253

题意：给n个锯完后的木头的长度。每次锯a+b长度的木头花费a+b。问原来的一整块大木头锯完最少花费多少。

思路：贪心，Huffman编码。用优先队列，每次把最小的两块拿出来相加再塞回队列，队列里最后一个元素就是答案。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const double _e = 10e-6;
const int maxn = 2e4 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;

int n;

struct cmp
{
	bool operator()(int a, int b)
	{
		return a > b;
	}
};

void solve()
{
	priority_queue<int, vector<int>, cmp> que;
	for (int i = 1; i <= n; i++) {
		scanf("%d", &x);
		que.push(x);
	}
	ll ans = 0;
	while (que.size() > 1) {
		int a = que.top(); que.pop();
		int b = que.top(); que.pop();
		que.push(a + b);
		ans += a + b;
	}
	printf("%lld\n", ans);
}

int main()
{
	while (~scanf("%d", &n)) 
		solve();
	return 0;
}

 

POJ #3259 : Wormholes

传送门：http://poj.org/problem?id=3259

题意：给出n个点，m条正的无向边，w条负的有向边。问有没有负环。

思路：Bellman-Ford判断有没有负环。如果有点在第n次还在更新，那就有负环。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const double _e = 10e-6;
const int maxn = 510;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;

struct edge
{
	int from, to, cost;
};

int t, n, m, w;
edge e[6010];

bool loop()
{
	int d[maxn]; cl0(d);
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m * 2 + w; j++) {
			edge v = e[j];
			if (d[v.to] > d[v.from] + v.cost) {
				d[v.to] = d[v.from] + v.cost;
				if (i == n)
					return true;
			}
		}
	}
	return false;
}

int main()
{
	scanf("%d", &t);
	while (t--) {
		scanf("%d%d%d", &n, &m, &w);
		for (int i = 1; i <= m; i++) {
			scanf("%d%d%d", &x, &y, &z);
			e[i * 2 - 1] = edge{ x,y,z };
			e[i * 2] = edge{ y,x,z };
		}
		for (int i = m * 2 + 1; i <= m * 2 + w; i++) {
			scanf("%d%d%d", &x, &y, &z);
			e[i] = edge{ x,y,-z };
		}
		if (loop())
			puts("YES");
		else
			puts("NO");
	}
	return 0;
}

 

LightOJ #1074 : Extended Traffic

传送门：http://lightoj.com/login_main.php?url=volume_showproblem.php?problem=1074

题意：给出n个路口m条有向边，每个路口有一个忙碌值。有q个询问，问从点1到询问的点最小的花费和，若小于3或无法到达则输出‘?’。花费为(终点忙碌值-起点忙碌值)^3。

思路：因为是3次方，所以是可能存在负环的。还是用Bellman-Ford求单源最短路+判哪些点在负环里。

多开一个cycle数组，初始化为0，和算最短路一样不断更新，最终所有cycle[i]<0的点i都在负环里。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9 + 10;
const double _e = 10e-6;
const int maxn = 210;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;
char c;

struct edge
{
	int from, to, cost;
};

int t, n, m, q;
int cost[maxn], d[maxn], cycle[maxn];
edge e[maxn*maxn];

int cal(int a, int b)
{
	return (b - a)*(b - a)*(b - a);
}

void solve()
{
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			edge v = e[j];
			if (d[v.to] > d[v.from] + v.cost) {
				d[v.to] = d[v.from] + v.cost;
				cycle[v.to] = cycle[v.from] + v.cost;
			}
		}
	}
}

int main()
{
	scanf("%d", &t);
	for (int _ = 1; _ <= t; _++) {	
		scanf("%d", &n);
		for (int i = 1; i <= n; i++)
			d[i] = INF;
		d[1] = 0; cl0(cycle);
		for (int i = 1; i <= n; i++)
			scanf("%d", &cost[i]);
		scanf("%d", &m);
		for (int i = 1; i <= m; i++) {
			scanf("%d%d", &x, &y);
			e[i] = edge{ x,y,cal(cost[x],cost[y]) };
		}
		solve(); 
		scanf("%d", &q);
		printf("Case %d:\n", _);
		while (q--) {
			scanf("%d", &x);
			if (d[x] < 3 || d[x] == INF || cycle[x] < 0)puts("?");
			else printf("%d\n", d[x]);
		}
	}
	return 0;
}

 

POJ #1949 : Chores

传送门：http://poj.org/problem?id=1949

题意：有n件家务活，每个都有完成需要的时间和前置家务。问全部完成最快要多久。

思路：优先队列，记录点和结束该任务的时间，按时间从小到大排。记每个点的入度，每当入度为0就进队列，不断维护最大值就是答案。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9 + 10;
const double _e = 10e-6;
const int maxn = 10010;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;
char c;

int n, m, ans;
int cost[maxn], in[maxn];
vector<int> son[maxn];

struct node {
	int id;
	int ans;
};

struct cmp {
	bool operator()(node a, node b) {
		return a.ans > b.ans;
	}
};

void solve()
{
	priority_queue<node, vector<node>, cmp> que;
	for (int i = 1; i <= n; i++)
		if (in[i] == 0)que.push(node{ i,cost[i] });
	while (!que.empty()) {
		node u = que.top(); que.pop();
		ans = max(ans, u.ans);
		for (int i = 0; i < son[u.id].size(); i++) {
			int v = son[u.id][i];
			in[v]--;
			if (in[v] == 0)
				que.push(node{ v, u.ans + cost[v] });
		}
	}
}

int main()
{
	while (~scanf("%d", &n)) {
		for (int i = 1; i <= n; i++)
			son[i].clear();
		cl0(in); ans = 0;
		for (int i = 1; i <= n; i++) {
			scanf("%d%d", &cost[i], &m);
			while (m--) {
				scanf("%d", &x);
				son[x].push_back(i);
				in[i]++;
			}		
		}
		solve();
		printf("%d\n", ans);
	}
	return 0;
}

 

POJ #1860 : Currency Exchange

传送门：http://poj.org/problem?id=1860

题意：有n种货币以及m种交易，给定初始时有的货币种类（1种）和货币金额。每种交易都指定2种货币，以及交易的汇率和手续费。问有没有可能钱越换越多。

思路：实际上就是判负环。Bellman-Ford判断即可。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const double _e = 10e-6;
const int maxn = 1e4 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;
char c;

struct edge
{
	int from, to;
	double r, c;
};

int n, m, s;
double ss, a1, a2, a3, a4;
edge e[210];

bool loop()
{
	double d[maxn]; cl0(d); d[s] = ss;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m * 2; j++) {
			edge v = e[j];
			if (d[v.to] < (d[v.from] - v.c)*v.r) {
				d[v.to] = (d[v.from] - v.c)*v.r;
				if (i == n)
					return true;
			}
		}
	}
	return false;
}

int main()
{
	while (~scanf("%d%d%d%lf", &n, &m, &s, &ss)) {
		for (int i = 1; i <= m; i++) {
			scanf("%d%d%lf%lf%lf%lf", &x, &y, &a1, &a2, &a3, &a4);
			e[i * 2 - 1] = edge{ x,y,a1,a2 };
			e[i * 2] = edge{ y,x,a3,a4 };
		}
		if (loop()) puts("YES");
		else puts("NO");
	}	
	return 0;
}

 

最短路&&优先队列优化->HDU2544
忘川蒿里
08-09 729
最短路&&优先队列优化->HDU2544Dijkstra算法思想： 　　　（1）在任意时刻，我们都要得到从源点到所有顶点的估算距离，并维持一个顶点集合S，若顶点v在S中，则说明从源点到v的最短路径已知； 　　　（2）在每一次将不在S中的顶点v加到S中去时，总是选择从源点到v的估算距离最小的； 　　　（3）顶点v加入S中之后，对于所有与v相邻的顶点（不属于S），更新它们的估算距
用优先队列优化dijikstra算法
BlackCarDriver的博客
03-14 922
dijikstra算法之优化版 在上一个博客中的dijikstra最短路算法，虽然流程简单，但是由于使用邻接表的方式存储数据，空间复杂度（n^2）实在不理想，时间复杂度同样不佳。。。。在acm比赛中若不加以优化，往往超时无疑。 为解决这个问题，在实际应用或比赛中常常使用优先队列优化。如下是我写的dijikstr算法优先队列优化版。用于自己日后复习和分享知识用，若有错误或不足之处请留言。 dijik...
优先队列实现最短路
Qingzhx的博客
04-24 280
一时间没找着最短路问题，仿照L2-4 深入虎穴 (25 分)的输入捏了一个 #include <bits/stdc++.h> using namespace std; typedef long long ll; int main() { int n; cin>>n; int a[n+1][n+1]; for(int i=1;i<=n;i++) { int m; cin>>m;
用优先队列实现最短路
ZZULI_星.夜
05-15 2600
致读者 致读者： 博主是一名数据科学与大数据专业大二的学生，真正的一个互联网萌新，写博客一方面是为了记录自己的学习历程，一方面是希望能够帮助到很多和自己一样处于困惑的读者。由于水平有限，博客中难免会有一些错误，有纰漏之处恳请各位大佬不吝赐教！之后会写大数据专业的文章哦。尽管当前水平可能不及各位大佬，但我会尽我自己所能，做到最好☺。——天地有正气，杂然赋流形。下则为河岳，上则为日星。 前言 最短路其实一开始我也不会，感觉，这都是什么啊，好复杂。???? ????然后自己给自己制造心理负担。 然后经过若干次
HDU - 2544 最短路 (dijkstra 优先队列优化)
hhh
08-07 849
题目链接 是一个求最短路的模板题(题目中都写最短路23333)。         一般建图比较方便的是用邻接矩阵的方法，但是对于dijkstra算法来说，其时间复杂度为O（)。        我们有一个更好的优化算法：即利用优先队列（小根堆）进行时间上的优化，复杂度可以达到O（(m+n)logm)。 （题外话：vector真心真心好用，vector是已经封装了的，又不像链表那么麻烦，最关键...
最短路（Dijkstra + 优先队列优化）
SPIDER的博客
11-18 600
堆优化 堆优化的主要思想就是使用一个优先队列（就是每次弹出的元素一定是整个队列中最小的元素）来代替最近距离的查找，用邻接表代替邻接矩阵，这样可以大幅度节约时间开销。 在这里有几个细节需要处理： 首先来讲，优先队列的数据类型应该是怎样的呢？ 我们知道优先队列应该用于快速寻找距离最近的点。由于优先队列只是将最小的那个元素排在前面，因此我们应该定义一种数据类型，使得它包含该节点的编号以及该节点当前与...
CSP-S复习：图论题选讲
summ1ts的博客
10-07 1736
今天跟着南外复习的图论，十道题，感觉质量不错，就拿出来总结一下。
Dijkstra--解决非负权边的单源最短路算法
My vegetable has exploded.
05-12 1572
Dijkstra天下第一!
信息学奥赛复赛复习04-CSP-J2019-04-加工零件-位运算、整数映射0或1、结构体、初始化列表构造、动态数组、二维动态数组、队列、宽度优先搜索
ya888g
09-26 1368
编号为 1 的工人想生产第 5 阶段的零件，需要编号为 2 和 5 的工人生产第 4 阶段的零件，需要编号为 1,3,4 的工人生产第 3 阶段的零件，需要编号为 2,3,4,5 的工人生产第 2 阶段的零件，需要全部工人生产第 1 阶段的零件，需要全部工人提供原材料。编号为 1 的工人想生产第 4 阶段的零件，需要编号为 2 和 5 的工人生产第 3 阶段的零件，需要编号为 1,3,4 的工人生产第 2 阶段的零件，需要编号为 2,3,4,5 的工人生产第 1 阶段的零件，需要全部工人提供原材料。
面试必刷的算法题 - 剑指offer题集Java实现
clonechen
04-12 3427
本文的题目均来自LeetCode的剑指offer题库 文章目录基础知识数据结构面试题03.数组中重复的数字面试题04.二维数组中的查找面试题05.替换空格面试题06.从尾到头打印链表面试题07.重建二叉树面试题09.用两个栈实现队列算法与数据操作面试题10-I.斐波那契数列面试题11.旋转数组的最小数字面试题12.矩阵中的路径面试题13.机器人的运动范围[面试题14-I. 剪绳子](https:/...
优先队列（堆）优化最短路Dijstra算法
weixin_45842558的博客
10-15 290
在队友的强烈建议（压迫）下放弃了可能会被卡死的优先队列优化SPFA去计算最短路于是现学了Dij算法。为了避免某比赛上忘记，疯狂背板子（怨念.jpg） 题目来源：洛谷P4779 模板题 Dijkstra算法适用于边权为正的无向和有向图，不适用于有负边权的图 基本思想： 将图上的初始点看作一个集合S，其它点看作另一个集合 根据初始点，求出其它点到初始点的距离dis[i] （若相邻，则dis[i]为边权值；若不相邻，则d[i]为无限大） 选取最小的dis[i]（记为dis[x]），并将此dis[i]边对应的
优先队列优化最短路（priority_queue）
m0_51938608的博客
03-06 387
优先队列优化Dijkstra算法 Dijkstra算法在变更起点时会选择没有选择过的最近的点作为起点，优先队列的好处就在于可以在O(log n)的时间内找到那个新起点。 用法 1. 需要包含头文件#include 2. 一共有三个参数 ： type：数据类型； container：实现优先队列的底层容器； function：元素之间的比较方式； 模板： typedef pair<int,int> P; priority_queue<P, vector<P>, greater&l
最短路（Dijkstra+优先队列）
fire__ice的专栏
05-11 703
const int INF = 0xfffffff; const int M = 1005; Graph g; int Dis[M]; struct Node{ Node(){} Node(int Len, int Ind):len(Len),ind(Ind){} int len,ind; bool operator<(const Node& node) const{ return
最短路径(优先队列)
qq_46394490的博客
03-03 441
/* #include <iostream> #include <vector> #include <string> #include <cstring> using namespace std; struct Edge{ int length; int to; Edge(int to,int length):to(to),length(length){} }; vector<Edge> graph[10]; int dis
优先队列——最短路径
huantingyizhan的博客
02-25 1013
/* 7 10 1 2 2 1 3 5 2 3 4 3 4 2 2 4 6 4 6 1 2 5 10 5 6 3 5 7 5 6 7 9 0 2 5 7 12 8 17 */ #include<iostream> #include<vector> #include<queue> using namespace std; const int MAX_V=10...
优先队列解决最短路问题
u011867401的专栏
10-13 619
用优先队列解决最短路问题，会将复杂度降低
优先队列+狄克斯特拉 求单源最短路
weixin_50547586的博客
01-06 242
优先队列+狄克斯特拉 求单源最短路 先上模板： #include<bits/stdc++.h> using namespace std; #define ll long long #define MAX 100005 #define MAXN ~(1<<31) #define pb push_back #define INF 0x3f3f3f3f priority_queue<pair<int,int> > p; int color[MAX]; int d
最短路Dijstra算法（复杂节点，优先队列，C++）
Comet的博客
04-11 1029
最短路径算法在众多领域都有广泛应用，众多网络流问题都基于或部分基于最短路问题。一种经典的有效解决最短路问题的算法——dijkstra 算法已经得到广泛应用。dijkstra算法是一种label setting算法，适用于一对多，即某一点到其他各点的最短路。通常情况下的最短路算法依赖于邻接矩阵，用以描述网络的拓扑结构。然而在多数情况下，网络中点包含了多个特征，如位置，前后节点等。本文用结构体（类也可以）来表示网络中的节点，用C++语言实现dijkstra算法。
优先队列优化的Dijk单源最短路算法
HZAU_ZXB的博客
05-09 1348
开始以为优先队列优化的是最短路的时间复杂度，现在看来，更多的是优化空间复杂度 我们是先用那个把图变成树的数据结构来存储图中所有的边 如果我们用邻接表储存边的话，空间复杂度为n^2也就是说我们的数组最大能开到5000*5000 现在我们储存边，那么就可以在点较多而边较少的情况下搞定了 下面附上注释详尽的代码 题目：poj3159 这个题目其实是差分约束+Dijk不懂差分约束的话可以
排序算法 快速排序 ⭐⭐⭐⭐ 归并排序 ⭐⭐⭐ 桶排序 ⭐⭐（特殊场景） 注：冒泡/选择/插入排序极少直接考察，但需理解原理 搜索算法 DFS/BFS ⭐⭐⭐⭐⭐（90%比赛必考） 记忆化搜索 ⭐⭐⭐⭐（DP优化常用） 剪枝技巧 ⭐⭐⭐（DFS优化） 动态规划 一维普通DP（爬楼梯/打家劫舍类） ⭐⭐⭐⭐ 背包DP（01背包/完全背包） ⭐⭐⭐ 树形DP（最近公共祖先相关） ⭐⭐ 数据结构 栈（表达式计算/括号匹配） ⭐⭐⭐ 队列（BFS标准实现） ⭐⭐⭐ 并查集 ⭐⭐⭐⭐（连通性问题） 堆（优先队列实现贪心） ⭐⭐⭐ 树状数组 ⭐⭐（区间求和问题） 图论 最小生成树（Prim/Kruskal） ⭐⭐⭐ 单源最短路（Dijkstra） ⭐⭐⭐拓扑排序 ⭐⭐ 数学与数论 初等数论（GCD/质数判断/快速幂） ⭐⭐⭐⭐ 排列组合 ⭐⭐⭐ 模运算与逆元 ⭐⭐ 其他重点 二分查找（边界处理） ⭐⭐⭐⭐ 贪心算法（区间调度/ Huffman树） ⭐⭐⭐ 双指针技巧 ⭐⭐⭐ 这是优快云给出的高频算法 1. 搜索算法（DFS/BFS）** [⭐️⭐️⭐️⭐️⭐️] - **出现场景**：几乎每年必考，如迷宫路径、连通性问题、排列组合枚举等。 - **真题示例**： - 第七届“剪邮票”问题（DFS遍历连通性）； - 第十二届“砝码称重”隐含记忆化搜索思想； - 第十四届“接龙数列”（字符串搜索与剪枝）。 --- ### **2. 动态规划（DP）** [⭐️⭐️⭐️⭐️] - **高频子类**： - **背包DP**：如第十二届“砝码称重”（01背包变种）； - **线性DP**：第七届“煤球数目”（递推问题）、第十四届“接龙数列”（状态转移）； - **树形DP**：偶有涉及（如路径计数问题）。 --- ### **3. 贪心算法** [⭐️⭐️⭐️⭐️] - **高频题型**：区间调度、策略选择。 - **真题示例**： - 第四届“翻硬币”（相邻翻转策略）； - 第九届“乘积最大”（双指针结合正负分析）。 --- ### **4. 数学与数论** [⭐️⭐️⭐️⭐️] - **高频内容**： - **初等数论**：因数分解、模运算（第十二届“货物摆放”）； - **排列组合**：第七届“凑算式”全排列问题； - **容斥原理**：整数分解问题（第十二届第二场D题）。 --- ### **5. 排序与二分查找** [⭐️⭐️⭐️] - **高频应用**： - **快速排序**：第七届填空题直接考察代码补全； - **二分答案**：第十二届“直线”问题（排序去重优化）。 --- ### **6. 数据结构** [⭐️⭐️⭐️] - **高频结构**： - **栈与队列**：模拟题中常见（如第四届“翻硬币”隐含栈思想）； - **并查集**：图论连通性问题（如最小生成树）； - **树状数组/线段树**：区间查询问题（近年偶有涉及）。 --- ### **7. 图论** [⭐️⭐️⭐️] - **高频算法**： - **最短路径（Dijkstra/Floyd）**：第十二届“路径”直接考察； - **最小生成树（Kruskal/Prim）**：第十二届第二场“城邦”问题； - **拓扑排序**：第十四届“飞机降落”依赖关系问题。 二届“货物摆放”）； - **排列组合**：第七届“凑算式”全排列问题； - **容斥原理**：整数分解问题（第十二届第二场D题）。 --- ### **5. 排序与二分查找** [⭐️⭐️⭐️] - **高频应用**： - **快速排序**：第七届填空题直接考察代码补全； - **二分答案**：第十二届“直线”问题（排序去重优化）。 --- ### **6. 数据结构** [⭐️⭐️⭐️] - **高频结构**： - **栈与队列**：模拟题中常见（如第四届“翻硬币”隐含栈思想）； - **并查集**：图论连通性问题（如最小生成树）； - **树状数组/线段树**：区间查询问题（近年偶有涉及）。 --- ### **7. 图论** [⭐️⭐️⭐️] - **高频算法**： - **最短路径（Dijkstra/Floyd）**：第十二届“路径”直接考察； - **最小生成树（Kruskal/Prim）**：第十二届第二场“城邦”问题； - **拓扑排序**：第十四届“飞机降落”依赖关系问题。 这是deepseek给我的哪个准确点呢，因为不一样所以请你再回顾一下十六届以前广东省b组的高频算法按出现算法频率，给我输出一下
最新发布
03-26
他们可能是在准备蓝桥杯或其他编程比赛，想要了解哪些算法最常出现，以便重点复习。 首先，用户给出两个不同的资料源，优快云和DeepSeek，两者在分类和重点上有所不同。比如，优快云提到的搜索算法（DFS/BFS）出现频率...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值