【C++】《图论习题集》更新至 单源最短路的建图方式

最新推荐文章于 2022-12-29 08:30:00 发布
最新推荐文章于 2022-12-29 08:30:00 发布
阅读量364 收藏
点赞数 2
分类专栏： C++ dijkstra spfa 文章标签： 算法 图论 并查集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52765554/article/details/121600382
版权
C++ 同时被 3 个专栏收录
221 篇文章 3 订阅
订阅专栏
dijkstra
1 篇文章 0 订阅
订阅专栏
spfa
1 篇文章 0 订阅
订阅专栏

2021-11-28

目录

Ⅰ . 单源最短路建图方式

1129. 热浪

题目链接：1129. 热浪
CODE

//朴素版dijkstra
#include<bits/stdc++.h>
using namespace std;
const int N = 3010;
int g[N][N];
int dist[N];
bool st[N];
int n, m, sta, ed;
int dijkstra(int sta,int ed)
{
    dist[sta]=0;
	for (int i = 0; i < n - 1; i++)
	{
		int t = -1;
		for (int j = 1; j <= n; j++)if (!st[j] && (t == -1 || dist[t] > dist[j]))t = j;
		st[t] = true;
		for (int j = 1; j <= n; j++)dist[j] = min(dist[j], dist[t] + g[t][j]);
	}
	return dist[ed];
}
int main()
{
	cin >> n >> m >> sta >> ed;
	memset(g, 0x3f, sizeof g);
	memset(dist,0x3f,sizeof dist);
	for (int i = 0; i < m; i++)
	{
		int a, b, c;
		cin>> a >> b >> c;
		g[a][b] = g[b][a] = min(g[a][b], c);
	}
	cout << dijkstra(sta, ed) << endl;
	return 0;
}
//堆优化dijkstra
#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int N = 3010;
const int M = 20010;
typedef pair<int, int>PII;
int w[M], e[M], ne[M], h[N], idx;
priority_queue<PII, vector<PII>, greater<PII>>heap;
bool st[N];
int dist[M];
int n, m, sta, ed;
void add(int a, int b, int c)
{
	e[idx] = b;
	w[idx] = c;
	ne[idx] = h[a];
	h[a] = idx++;
}
int dijkstra(int sta, int ed)
{
	heap.push({ 0,sta });
	dist[sta] = 0;
	while (heap.size())
	{
		auto t = heap.top();
		heap.pop();
		int distance = t.x, ver = t.y;
		if (st[ver])continue;
		st[ver] = true;
		for (int i = h[ver]; ~i; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > distance + w[i])
			{
				dist[j] = distance + w[i];
				heap.push({ dist[j],j });
			}
		}
	}
	return dist[ed];
}
int main()
{
	cin >> n >> m >> sta >> ed;
	memset(h, -1, sizeof h);
	memset(dist, 0x3f, sizeof dist);
	for (int i = 0; i < m; i++)
	{
		int a, b, c;
		cin>> a >> b >> c;
		add(a, b, c);
		add(b, a, c);
	}
	cout << dijkstra(sta, ed) << endl;
	return 0;
}
//spfa
#include <bits/stdc++.h>
using namespace std;
const int N = 3010, M = 20010;
int w[M], e[M], ne[M], h[N], idx;
int dist[N];
bool st[N];
int n, m, sta, ed;
void add(int a, int b, int c)
{
	e[idx] = b;
	w[idx] = c;
	ne[idx] = h[a];
	h[a] = idx++;
}
int spfa(int sta,int ed)
{
	queue<int>q;
	q.push(sta);
	dist[sta] = 0;
	st[sta] = true;
	while (q.size())
	{
		auto t = q.front();
		q.pop();
		st[t] = false;
		for (int i = h[t]; ~i; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[t] + w[i])
			{
				dist[j] = dist[t] + w[i];
				if (!st[j])
				{
					st[j] = true;
					q.push(j);
				}
			}
		}
	}
	return dist[ed];
}
int main()
{
	cin >> n >> m >> sta >> ed;
	memset(h, -1, sizeof h);
	memset(dist, 0x3f, sizeof dist);
	for (int i = 0; i < m; i++)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
		add(b, a, c);
	}
	cout << spfa(sta, ed) << endl;
	return 0;
}

1128. 信使

题目链接：信使

//spfa
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 500;
int e[N], ne[N], w[N], h[N], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
	e[idx] = b;
	w[idx] = c;
	ne[idx] = h[a];
	h[a] = idx++;
}
int spfa()
{
	queue<int>q;
	st[1] = true;
	dist[1] = 0;
	q.push(1);
	while (q.size())
	{
		auto t = q.front();
		q.pop();
		st[t] = false;
		for (int i = h[t]; ~i; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[t] + w[i])
			{
				dist[j] = dist[t] + w[i];
				if (!st[j])
				{
					st[j] = true;
					q.push(j);
				}
			}
		}
	}
	int res = 0;
	for (int i = 1; i <= n; i++)
	{
		if (dist[i] == 0x3f3f3f3f)return -1;
		res = max(res, dist[i]);
	}
	return res;
}
int main()
{
    memset(h,-1,sizeof h);
    memset(dist,0x3f,sizeof dist);
	cin >> n >> m;
	for (int i = 0; i < m; i++)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
		add(b, a, c);
	}
	cout << spfa() << endl;
	return 0;
}
//朴素dijkstra
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int g[N][N];
int n, m;
int dist[N];
bool st[N];
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 0; i < n; i++)
    {
        int t = -1;
        for (int j = 1; j <= n; j++)
        {
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        }
        st[t] = true;
        for (int j = 1; j <= n; j++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);
    }
    int res = -1;
    for (int i = 1; i <= n; i++)
    {
        if (dist[i] == 0x3f3f3f3f)return -1;
        res = max(res, dist[i]);
    }
    return res;
}
int main()
{
    cin >> n >> m;
    memset(g, 0x3f, sizeof g);
    for (int i = 1; i <= m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        if (a == b)continue;
        g[a][b] = min(g[a][b], c);
        g[b][a] = min(g[b][a], c);
    }
    cout << dijkstra() << endl;
    return 0;
}
//堆优化dijkstra
#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int N = 210 * 2;
typedef pair<int, int>PII;
int e[N], h[N], ne[N], w[N], dist[N], idx;
bool st[N];
int n, m;
void add(int a, int b, int c)
{
    e[idx] = b;
    ne[idx] = h[a];
    w[idx] = c;
    h[a] = idx++;
}
int dijkstra()
{
    priority_queue<PII, vector<PII>, greater<PII>>heap;
    memset(dist, 0x3f, sizeof dist);
    heap.push({ 0,1 });
    dist[1] = 0;
    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();
        int ver = t.y, distance = t.x;
        if (st[ver])continue;
        for (int i = h[ver]; ~i; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({ dist[j],j });
            }
        }
    }
    int res = -1;
    for (int i = 1; i <= n; i++)
    {
        if (dist[i] == 0x3f3f3f3f)return -1;
        res = max(res, dist[i]);
    }
    return res;
}
int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
        add(b, a, c);
    }
    cout << dijkstra() << endl;
    return 0;
}
//floyd
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m;
int d[N][N];
void floyd()
{
    for (int k = 1; k <= n; k++)
    {
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
            }
        }
    }
}
int main()
{
    cin >> n >> m;
    memset(d, 0x3f, sizeof d);
    for (int i = 1; i <= n; i++)d[i][i] = 0;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        d[a][b] = d[b][a] = min(d[a][b], c);
    }
    floyd();
    int res = -1;
    for(int i=1;i<=n;i++)
    {
        if (d[1][i] == 0x3f3f3f3f)
        {
            cout << -1 << endl; 
            return 0;
        }
        res = max(res, d[1][i]);
    }
    cout << res << endl;
    return 0;
}

1127. 香甜的黄油

题目链接：香甜的黄油

//spfa
#include <bits/stdc++.h>
using namespace std;
const int N = 810, M = 3000;
int h[N], ne[M], e[M], idx, w[M];
int dist[N];
bool st[N];
int id[N], T, n, m;
void add(int a, int b, int c)
{
	e[idx] = b;
	w[idx] = c;
	ne[idx] = h[a];
	h[a] = idx++;
}
int spfa(int sta)
{
	memset(dist, 0x3f, sizeof dist);
	memset(st, 0, sizeof st);
	queue<int>q;
	q.push(sta);
	st[sta] = true;
	dist[sta] = 0;
	while (q.size())
	{
		auto t = q.front();
		q.pop();
		st[t] = false;
		for (int i = h[t]; ~i; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[t] + w[i])
			{
				dist[j] = dist[t] + w[i];
				if (st[j])continue;
				st[j] = true;
				q.push(j);
			}
		}
	}
	int res = 0;
	for (int i = 1; i <= T; i++)
	{
		if (dist[id[i]] == 0x3f3f3f3f)return 0x3f3f3f3f;
		res += dist[id[i]];
	}
	return res;
}
int main()
{
	memset(h, -1, sizeof h);
	cin >> T >> n >> m;
	for (int i = 1; i <= T; i++)cin >> id[i];
	for (int i = 1; i <= m; i++)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
		add(b, a, c);
	}
	int res = 0x3f3f3f3f;
	for (int i = 1; i <= n; i++)
		res = min(res, spfa(i));
	cout << res << endl;
	return 0;
}
//dijkstra
#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int N = 1000, M = 3000, INF = 0x3f3f3f3f;
typedef pair<int, int>PII;
int dist[N];
bool st[N];
int h[N], ne[M], w[M], e[M], idx;
int T, n, m, id[N];
void add(int a, int b, int c)
{
	e[idx] = b;
	ne[idx] = h[a];
	w[idx] = c;
	h[a] = idx++;
}
int dijkstra(int x)
{
	memset(dist, 0x3f, sizeof dist);
	memset(st, 0, sizeof st);
	dist[x] = 0;
	priority_queue<PII, vector<PII>, greater<PII>>heap;
	heap.push({ dist[x],x });
	while (heap.size())
	{
		auto t = heap.top();
		heap.pop();
		int ver = t.y, distance = t.x;
		if (st[ver])continue;
		st[ver] = true;
		for (int i = h[ver]; ~i; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[ver] + w[i])
			{
				dist[j] = dist[ver] + w[i];
				heap.push({ dist[j],j });
			}
		}
	}
	int res = 0;
	for (int i = 1; i <= T; i++)
	{
		if (dist[id[i]] == 0x3f3f3f3f)return 0x3f3f3f3f;
		res += dist[id[i]];
	}
	return res;
}
int main()
{
	memset(h, -1, sizeof h);
	cin >> T >> n >> m;
	for (int i = 1; i <= T; i++)cin >> id[i];
	for (int i = 0; i < m; i++)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
		add(b, a, c);
	}
	int res = INF;
	for (int i = 1; i <= n; i++)res = min(res, dijkstra(i));
	cout << res << endl;
	return 0;
}

1126. 最小花费

题目链接：最小花费
CODE

#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
double g[N][N];
bool st[N];
double dist[N];
int n, m;
int a, b, c;
int s, t;
void dijkstra()
{
	dist[s] = 1;
	for (int i = 0; i < n; i++)
	{
		int t = -1;
		for (int j = 1; j <= n; j++)
			if (!st[j] && (t == -1 || dist[j] > dist[t]))
				t = j;
		st[t] = true;
		for (int j = 1; j <= n; j++)
			dist[j] = max(dist[j], dist[t] * g[t][j]);
	}
}
int main()
{
	cin >> n >> m;
	for (int i = 0; i < m; i++)
	{
		cin >> a >> b >> c;
		double z = (100.0 - c) / 100;
		g[a][b] = g[b][a] = max(g[a][b], z);
	}
	cin >> s >> t;
	dijkstra();
	printf("%.8f", 100 / dist[t]);
	return 0;
}

920 . 最优乘车

题目链接：最有乘车
CODE

#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int n, m;
int stop[N];
bool g[N][N];
int dist[N];
void bfs()
{
	memset(dist, 0x3f, sizeof dist);
	queue<int>q;
	q.push(1);
	dist[1] = 0;
	while (q.size())
	{
		auto t = q.front();
		q.pop();
		for (int i = 1; i <= n; i++)
		{
			if (g[t][i] && dist[i] > dist[t] + 1)
			{
				dist[i] = dist[t] + 1;
				q.push(i);
			}
		}
	}
}
int main()
{
	cin >> m >> n;
	string line;
	getchar();
	while (m--)
	{
		getline(cin, line);
		stringstream ssin(line);
		int cnt = 0, p;
		while (ssin >> p)stop[cnt++] = p;
		for (int i = 0; i < cnt; i++)
		{
			for (int j = i + 1; j < cnt; j++)
			{
				g[stop[i]][stop[j]] = true;
			}
		}
	}
	bfs();
	if (dist[n] == 0x3f3f3f3f)puts("NO");
	else cout << max(dist[n] - 1, 0) << endl;
	return 0;
}
leimingzeOuO
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++图论SPFA算法例题———————最优贸易
C2020lax的博客
11-09 1213
题目描述： C 国有 n个大城市和m 条道路，每条道路连接这n 个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这m 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为1 条。C 国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。商人阿龙...
图论习题
cheng__yu_的博客
10-29 204
习题2020秦皇岛 K. Kingdom's Power 2020秦皇岛 K. Kingdom’s Power 链接：https://codeforces.com/gym/102769/problem/K 题意： n 个城市可以看做一棵以 1 为根的树，在城市 1 有无穷支军队。每天可以派遣一支军队移动一次。问最少需要几天才能使军队走遍所有的城市 思路：容易想到直接贪心，在叶节点的位置的军队，要么就是从其他叶节点走过来，要么就是从 1 号节点走过来。 首先将每个节点的子节点按照叶节点的深度排序，按贪心的思
图论问题的算法 (C++)
ghost_him的博客
04-07 1638
图论问题的算法 有向图的拓扑排序 单源最短路径算法 多源最短路径算法 最小生成树算法 染色法判定二分图
HDU5521Meeting（最短路建图）
Rain
07-29 372
Meeting Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others) Total Submission(s): 2988    Accepted Submission(s): 952 Problem Description Bessie and her f
2022级图论-欧拉回路和最短路-题解
01-28
**图论基础** 在计算机科学和数学中，图论是一门重要的理论，它研究由顶点和连接这些顶点的边组成的结构，即图。在2022级的图论课程中，学生们将深入学习两个核心概念：欧拉回路和最短路径。 **欧拉回路** 欧拉...
图论matlab实现，各种图论的求解，最短路、哈密尔顿回路等等
09-07
1. **最短路算法**：最短路问题是在图中找到从一个起点到其他所有顶点的最短路径。Dijkstra算法是最常用的单源最短路径算法，适用于有向无权图或非负权重图。Floyd-Warshall算法则可以解决所有对间的最短路径问题，...
aa.zip_C++ 图论的库_bellman_starfish_单源最短路径_图论最小路径
09-24
图论算法库 C++ 语言实现 代码内容 图论算法库，包括以下算法： 单源最短路径 Dijkstra 算法 单源最短路径 Bellman-Ford 算法 最小生成树 Prim 算法 每对节点间最短路径 Flod-Warshall 算法 语言 C++ 编译平台 ...
图论基础_C++_学习_C++图论_图论方法c++_
10-02
综上所述，"图论基础_C++_学习_C++图论_图论方法c++_"的主题涵盖了图论的基本概念、C++中的图表示以及相关的算法实现。通过深入学习这部分内容，你将能够利用图论解决各种复杂的计算问题，并提升自己的编程能力。
cpp代码-dijkstra单源最短路
07-14
【cpp代码-dijkstra单源最短路】 在计算机科学中，Dijkstra算法是解决图论问题的一个经典算法，尤其用于寻找图中一个节点到其他所有节点的最短路径。这个算法由荷兰计算机科学家艾兹格·迪科斯彻在1956年提出，主要...
C++入门经典习题答案（完整版）
01-24
C++入门经典 第三版的所有答案 里面是全英文的答案哦
C++图论提高例题讲解————Frogger
C2020lax的博客
01-30 543
题目描述： Freddy Frog is sitting on a stone in the middle of a lake. Suddenly he notices Fiona Frog who is sitting on another stone. He plans to visit her, but since the water is dirty and full of touris...
【c++图论】洛谷P2820局域网题目详解
贤鱼的博客
08-01 253
【c++图论】洛谷P2820局域网题目详解
C++基础动态规划与图论综合 挖地雷题解
C2020lax的博客
12-10 2274
题目描述： 在一个地图上有N个地窖，依次编号为1..N，每个地窖中埋有一定数量的地雷。同时，给出地窖之间的连接路径。 例如在下图中： 上图表示，地窖1可以挖到地窖2，地窖3；地窖2可以挖到地窖4；地窖3可以挖到地窖4，地窖5；地窖4可以挖到地窖5. 当地窖及其连接的数据给出之后，某人可以从任一处开始挖地雷，然后可以沿着某条路径接着往下挖（仅能选择一条路径），当某个地窖无连接时挖地雷工作结...
贤鱼的刷题日常---【c++图论】洛谷 P3366最小生成树
贤鱼的博客
07-29 412
图论/洛谷/P3366最小生成树模板详解
图论-最短路-Dijkstra算法&Floyd算 c++
会说话的肚子的学习轨迹
08-17 2291
最短路径解决了求解一个图中两顶点之间最短的路径问题。其中Dijkstra算法应用贪心法求解单源点到其余各点的最短路径问题；而Floyd算法则解决了图中任意两点间的最短路径问题。
C++图论 最短路问题总结
m0_62946761的博客
12-29 8778
C++ 图论关于最短路问题的总结，包括Dijkstra，Bellman_ford，spfa算法等。
C++实现图 - 04 最短路径
Newin2020的博客
06-20 2209
数据结构与算法专栏 —— C++实现迪杰斯特拉算法是一个单源点的一个最短路径算法，也就是说，我们这个算法会求得从一个顶点到其所有顶点的最短路径。这个算法需要用到邻接矩阵来存储所有边值，并且需要一个辅助数组来更新最短路径，需要一个路径数组存储最短路径的结点，还需要一个状态数组来判断当前结点是否已经加入最短路径。这样说可能会有点晕，我们还是先来看图，假设有这样一张图：现在，我们要找到结点 0 到结点 8 的最短路径，步骤如下：第一步：初始化我们上述提到的三个数组，将结点 0 加入数组中，并更新辅助数组即结点 0
C++编程练习(11)----“图的最短路径问题“（Dijkstra算法、Floyd算法）
oohaha_123的专栏
04-08 4719
1、Dijkstra算法 是一种
单源最短路是什么意思
最新发布
08-17
单源最短路问题是在给定一个图和一个起点，求解从该起点到图中所有其他顶点的最短路径的问题。最短路径是指在图中从起点到目标顶点的路径中，使得路径上所有边的权值和最小的路径。这个问题可以应用于许多实际生活场景，比如地图导航中求解两个位置之间的最短路径。在图论中，有多种算法可以解决单源最短路问题，其中包括Bellman-Ford算法和SPFA算法。Bellman-Ford算法通过对图进行多次松弛操作来求解最短路径，可以处理边权为负数的情况，但时间复杂度较高。SPFA算法通过使用队列记录已经松弛过的节点，避免了冗余计算，提高了算法的效率。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [最短路之单源最短路](https://blog.csdn.net/luomingjun12315/article/details/50377525)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

leimingzeOuO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值