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

最新推荐文章于 2023-04-11 14:58:22 发布
最新推荐文章于 2023-04-11 14:58:22 发布
阅读量191 收藏
点赞数
分类专栏： 算法课复习 文章标签： 图论 优先队列 最短路 负环
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40993793/article/details/86382353
版权

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 682
最短路&&优先队列优化->HDU2544Dijkstra算法思想： 　　　（1）在任意时刻，我们都要得到从源点到所有顶点的估算距离，并维持一个顶点集合S，若顶点v在S中，则说明从源点到v的最短路径已知； 　　　（2）在每一次将不在S中的顶点v加到S中去时，总是选择从源点到v的估算距离最小的； 　　　（3）顶点v加入S中之后，对于所有与v相邻的顶点（不属于S），更新它们的估算距
用优先队列优化dijikstra算法
BlackCarDriver的博客
03-14 876
dijikstra算法之优化版 在上一个博客中的dijikstra最短路算法，虽然流程简单，但是由于使用邻接表的方式存储数据，空间复杂度（n^2）实在不理想，时间复杂度同样不佳。。。。在acm比赛中若不加以优化，往往超时无疑。 为解决这个问题，在实际应用或比赛中常常使用优先队列优化。如下是我写的dijikstr算法优先队列优化版。用于自己日后复习和分享知识用，若有错误或不足之处请留言。 dijik...
优先队列实现最短路
Qingzhx的博客
04-24 242
一时间没找着最短路问题，仿照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;
HDU - 2544 最短路 (dijkstra 优先队列优化)
hhh
08-07 823
题目链接 是一个求最短路的模板题(题目中都写最短路23333)。         一般建图比较方便的是用邻接矩阵的方法，但是对于dijkstra算法来说，其时间复杂度为O（)。        我们有一个更好的优化算法：即利用优先队列（小根堆）进行时间上的优化，复杂度可以达到O（(m+n)logm)。 （题外话：vector真心真心好用，vector是已经封装了的，又不像链表那么麻烦，最关键...
用优先队列实现最短路
ZZULI_星.夜
05-15 2541
致读者 致读者： 博主是一名数据科学与大数据专业大二的学生，真正的一个互联网萌新，写博客一方面是为了记录自己的学习历程，一方面是希望能够帮助到很多和自己一样处于困惑的读者。由于水平有限，博客中难免会有一些错误，有纰漏之处恳请各位大佬不吝赐教！之后会写大数据专业的文章哦。尽管当前水平可能不及各位大佬，但我会尽我自己所能，做到最好☺。——天地有正气，杂然赋流形。下则为河岳，上则为日星。 前言 最短路其实一开始我也不会，感觉，这都是什么啊，好复杂。???? ????然后自己给自己制造心理负担。 然后经过若干次
最短路（Dijkstra + 优先队列优化）
SPIDER的博客
11-18 523
堆优化 堆优化的主要思想就是使用一个优先队列（就是每次弹出的元素一定是整个队列中最小的元素）来代替最近距离的查找，用邻接表代替邻接矩阵，这样可以大幅度节约时间开销。 在这里有几个细节需要处理： 首先来讲，优先队列的数据类型应该是怎样的呢？ 我们知道优先队列应该用于快速寻找距离最近的点。由于优先队列只是将最小的那个元素排在前面，因此我们应该定义一种数据类型，使得它包含该节点的编号以及该节点当前与...
面试必刷的算法题 - 剑指offer题集Java实现
clonechen
04-12 3178
本文的题目均来自LeetCode的剑指offer题库 文章目录基础知识数据结构面试题03.数组中重复的数字面试题04.二维数组中的查找面试题05.替换空格面试题06.从尾到头打印链表面试题07.重建二叉树面试题09.用两个栈实现队列算法与数据操作面试题10-I.斐波那契数列面试题11.旋转数组的最小数字面试题12.矩阵中的路径面试题13.机器人的运动范围[面试题14-I. 剪绳子](https:/...
Edmond-Karp 最大流算法详解
Desgard_Duan
04-28 2966
知识梳理在「初识最大流问题」中，我们了解了什么是流网络模型、什么是最大流问题、以及在流网络中 的增广路（Augmenting Path）概念；在「Ford-Fulkerson 最大流求解...
CSP-S第二轮认证总结——提高组算法总结
weixin_43908980的博客
11-16 5018
目录 0.前言 一.动态规划——必考必考必考！！！ 1.背包 （1）01背包 （2）完全背包 2.线性DP 3.多维DP 二.贪心 三.模拟 四.图论——很灵活 1.最短路 （1）spfa （2）Dijkstra（+堆优化）时间复杂度远快于spfa 2.最小生成树 3.强连通分量 （1）有向图（含割点+缩点） （2）无向图（含割点） （3）无向图求每个连通...
算法基础课 acwing
Destiny_159的博客
09-06 6385
算法基础课 本博客基于acwing算法基础课,所做笔记 目的在于方便复习 课程链接:https://www.acwing.com/activity/content/introduction/11/ 主讲人:yxc 上课的时候理解算法的主要思想 课后把模板背过,并且调试题目,多重复,多敲 第一讲 基础算法 快速排序 调整区间的方法: 1、暴力，需要开辟两个数组 2、双指针 1、i往后面扫描，当i指向的数字小于等于x，就继续往后，当指向的数字大于x的时候停下 2、此时j往前面扫描，当j指向的数字大于x
优先队列（堆）优化最短路Dijstra算法
weixin_45842558的博客
10-15 258
在队友的强烈建议（压迫）下放弃了可能会被卡死的优先队列优化SPFA去计算最短路于是现学了Dij算法。为了避免某比赛上忘记，疯狂背板子（怨念.jpg） 题目来源：洛谷P4779 模板题 Dijkstra算法适用于边权为正的无向和有向图，不适用于有负边权的图 基本思想： 将图上的初始点看作一个集合S，其它点看作另一个集合 根据初始点，求出其它点到初始点的距离dis[i] （若相邻，则dis[i]为边权值；若不相邻，则d[i]为无限大） 选取最小的dis[i]（记为dis[x]），并将此dis[i]边对应的
优先队列优化最短路（priority_queue）
m0_51938608的博客
03-06 323
优先队列优化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 673
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 400
/* #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 970
/* 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 577
用优先队列解决最短路问题，会将复杂度降低
优先队列+狄克斯特拉 求单源最短路
weixin_50547586的博客
01-06 212
优先队列+狄克斯特拉 求单源最短路 先上模板： #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 927
最短路径算法在众多领域都有广泛应用，众多网络流问题都基于或部分基于最短路问题。一种经典的有效解决最短路问题的算法——dijkstra 算法已经得到广泛应用。dijkstra算法是一种label setting算法，适用于一对多，即某一点到其他各点的最短路。通常情况下的最短路算法依赖于邻接矩阵，用以描述网络的拓扑结构。然而在多数情况下，网络中点包含了多个特征，如位置，前后节点等。本文用结构体（类也可以）来表示网络中的节点，用C++语言实现dijkstra算法。
优先队列优化的Dijk单源最短路算法
HZAU_ZXB的博客
05-09 1298
开始以为优先队列优化的是最短路的时间复杂度，现在看来，更多的是优化空间复杂度 我们是先用那个把图变成树的数据结构来存储图中所有的边 如果我们用邻接表储存边的话，空间复杂度为n^2也就是说我们的数组最大能开到5000*5000 现在我们储存边，那么就可以在点较多而边较少的情况下搞定了 下面附上注释详尽的代码 题目：poj3159 这个题目其实是差分约束+Dijk不懂差分约束的话可以
数据结构期末复习：循环队列、算法复杂度与图的遍历
"福建工程学院的数据结构期末考试复习题涵盖了循环队列、时间复杂度、栈的操作、二叉树遍历、有向图拓扑排序、数组存储、图的深度优先遍历以及最小生成树等核心概念。" 1. 循环队列：循环队列是一种线性数据结构，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值