图的应用算法————数据结构//复习复习复习

已于 2022-07-10 19:08:04 修改
阅读量146 收藏
点赞数
分类专栏： 复习 文章标签： 算法 数据结构 图论
于 2022-07-02 14:08:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46154875/article/details/125570341
版权

一、最小生成树

Prim算法
（时间戳可以简化为标记）

#include <cstdio>
#include <queue>
#include <vector>
#define MAX 300000

using namespace std;

typedef struct MyStruct1
{//记录图中的结点和它到邻居的权
	int num = 0;
	vector<int> l;
	vector<int> w;
	int d = 0;
}Node;
typedef struct MyStruct2
{//记录前后结点和它们的权
	int first = 0;
	int weight = 0;
	int second = 0;
}Side;

Node node[MAX];//邻接表
int t = 1;//时间戳
int sum = 0;//计算总权重
int SUM = 0;//计算局部生成树的结点数
struct cmp
{//更改队列比较方法
	bool operator()(Side a, Side b)
	{
		return a.weight > b.weight;
	}
};
priority_queue<Side, vector<Side>, cmp> q;//用来储存局部生成树的边

void add(int num);//将边加入优先队列队列
void Prim();//从优先队列中拿最短的边

int main()
{
	int node_n, side_n;//节点数 边数
	scanf("%d%d", &node_n, &side_n);
	for (int i = 1; i <= node_n; i++)
		node[i].num = i;//初始化结点
	int first = 0, second = 0, weight = 0;
	for (int i = 1; i <= side_n; i++)
	{
		scanf("%d%d%d", &first, &second, &weight);//边 边 权
		node[first].l.push_back(second);//插入正向边
		node[first].w.push_back(weight);
		node[second].l.push_back(first);//插入反向边
		node[second].w.push_back(weight);
	}
	add(1);//将结点1的边加入队列 因为必有一条边去往任意结点
	while (SUM != node_n - 1)//判断局部生成树的节点数
		Prim();//从优先队列中拿最短的边
	printf("%d\n", sum);//输出总权重
	return 0;
}
void Prim()
{
	if (!q.empty())
	{
		Side topside;
		topside = q.top();
		q.pop();//取出最小权重边
		if (node[topside.second].d == 0)
		{//若后面的结点未被访问
			sum += topside.weight;
			SUM++;
			add(topside.second);//将后面结点的邻居加入优先队列
		}
	}
}
void add(int num)
{
	node[num].d = t++;//标记为已访问
	for (unsigned i = 0; i < node[num].l.size(); i++)
	{//将结点num的邻居加入优先队列
		if (node[node[num].l[i]].d == 0)
		{//若后面的结点未被访问
			Side side;
			side.first = num;
			side.second = node[num].l[i];
			side.weight = node[num].w[i];
			q.push(side);
		}
	}
}

Kruskal
（边的维护用优先队列 其底层实现为堆）

#include <cstdio>
#include <queue>
#define MAX 300000

using namespace std;

typedef struct MyStruct2
{//记录前后结点和它们的权
	int first = 0;
	int weight = 0;
	int second = 0;
}Side;

int sum = 0;//计算总权重
int SUM = 0;//计算局部生成树的结点数
int parent[MAX];
struct cmp
{//更改队列比较方法
	bool operator()(Side a, Side b)
	{
		return a.weight > b.weight;
	}
};
priority_queue<Side, std::vector<Side>, cmp> q;//用来储存局部生成树的边

void Kruskal();
int get_boss(int v);

int main()
{
	int node_n, side_n;//节点数 边数
	scanf("%d%d", &node_n, &side_n);
	for (int i = 1; i <= node_n; i++)
		parent[i] = i;//初始化
	int first = 0, second = 0, weight = 0;
	for (int i = 1; i <= side_n; i++)
	{
		scanf("%d%d%d", &first, &second, &weight);//边 边 权
		Side side;
		side.first = first;
		side.second = second;
		side.weight = weight;
		q.push(side);
	}
	while (SUM != node_n - 1)//判断局部生成树的节点数
		Kruskal();
	printf("%d\n", sum);//输出总权重
	return 0;
}
void Kruskal()
{
	if (!q.empty())
	{
		Side topside;
		topside = q.top();
		q.pop();//取出最小权重边
		int a = get_boss(topside.first);
		int b = get_boss(topside.second);
		if (a != b)
		{//判断边的两结点关系
			parent[a] = b;
			sum += topside.weight;
			SUM++;
		}
	}
}
int get_boss(int v)
{
	return parent[v] == v ? v : get_boss(parent[v]);
}

二、最短路径

Dijkstra
（路径输出不在主复习行列）

#include <cstdio>
#include <queue>
#include <stack>
#include <vector>
#define MAX 300000

using namespace std;

typedef struct MyStruct1
{//记录图中的结点和它到邻居的权
	int num = 0;
	unsigned distance = 0;//源点到该点的距离
	int btn = 0;//前继
	vector<int> l;//结点的邻居
	vector<unsigned> w;//结点的邻居权重
	int d = 0;//标记
}Node;
typedef struct MyStruct2
{//记录前后结点和它们的权
	int first = 0;
	unsigned weight = 0;
	int second = 0;
}Side;
Node node[MAX];//邻接表
int t = 1;//时间戳
int SUM = 0;//计算局部生成树的结点数
struct cmp
{//更改队列比较方法
	bool operator()(Side a, Side b)
	{
		return a.weight > b.weight;
	}
};
priority_queue<Side, vector<Side>, cmp> q;//用来储存局部生成树的边

void add(int num);//将边加入优先队列队列
void Dijkstra();//从优先队列中拿最短的边
void print_way(int origin, int destination);//输出最短路径

int main()
{
	int node_n, side_n;//节点数 边数
	scanf("%d%d", &node_n, &side_n);
	int origin = 1, destination;
	for (int i = 1; i <= node_n; i++)
		node[i].num = i;//初始化结点
	int first = 0, second = 0, weight = 0;
	for (int i = 1; i <= side_n; i++)
	{
		scanf("%d%d%d", &first, &second, &weight);//边 边 权
		node[first].l.push_back(second);//插入正向边
		node[first].w.push_back(weight);
		node[second].l.push_back(first);//插入反向边
		node[second].w.push_back(weight);
	}
	add(origin);//将起点的邻居加入队列 
	while (SUM != node_n - 1)//判断局部生成树的节点数while (node[destination].d == 0)//
		Dijkstra();//从优先队列中拿最短的边
	for (int i = 1; i <= node_n; i++)
		printf("结点%2d到达结点%d的距离:%5d\n", node[i].num, origin, node[i].distance);
	//printf("%d\n", node[destination].distance);
	printf("\n");
	for (int i = 1; i <= node_n; i++)
	{
		printf("%d", origin);
		print_way(origin, i);
		printf("\n");
	}
	return 0;
}
void print_way(int origin, int destination)
{
	std::stack<int> S;
	while (destination != origin)
	{
		S.push(destination);
		destination = node[destination].btn;
	}
	while (!S.empty())
	{
		printf("-->%d", S.top());
		S.pop();
	}
}
void Dijkstra()
{
	if (!q.empty())
	{
		Side topside;
		topside = q.top();
		q.pop();//取出最小权重边
		if (node[topside.second].d == 0)
		{//若后面的结点未被访问
			node[topside.second].distance = topside.weight;
			node[topside.second].btn = topside.first;
			SUM++;
			add(topside.second);//将后面结点的邻居加入优先队列
		}
	}
}
void add(int num)
{
	node[num].d = t++;//标记为已访问
	for (unsigned i = 0; i < node[num].l.size(); i++)
	{//将结点num的邻居加入优先队列
		if (node[node[num].l[i]].d == 0)
		{//若后面的结点未被访问
			Side side;
			side.first = num;
			side.second = node[num].l[i];
			side.weight = node[num].w[i] + node[num].distance;
			q.push(side);
		}
	}
}

Floyd
（优化版本利于理解算法 不在复习主行列）

#include <cstdio>
#include <algorithm>
#define MAX 300
#define maxlen 7001

using namespace std;

unsigned length[MAX][MAX];
void Floyd(unsigned length[][MAX], int node_n);
void Floyd_Push(unsigned length[][MAX], int node_n);
void RollFloyd(unsigned a[][MAX], int node_n);

int main()
{
	int node_n, side_n;
	scanf("%d%d", &node_n, &side_n);
	int origin, destination;
	scanf("%d%d", &origin, &destination);

	for (int i = 1; i <= node_n; i++)//初始化距离值
		for (int k = 1; k <= node_n; k++)
			if (i != k)
				length[i][k] = maxlen;

	for (int j = 1; j <= side_n; j++)
	{
		int first, second;
		unsigned weight;
		scanf("%d%d%d", &first, &second, &weight);
		length[first - 1][second - 1] = weight;
		length[second - 1][first - 1] = weight;
	}

	Floyd(length, node_n);
	printf("%d\n", length[origin][destination]);
	return 0;
}
void Floyd(unsigned length[][MAX], int node_n)
{//纯暴力
	for (int i = 0; i < node_n; i++)
		for (int j = 0; j < node_n; j++)
			for (int k = 0; k < node_n; k++)
				length[j][k] = min(length[j][k], length[j][i] + length[i][k]);
}
void Floyd_Push(unsigned length[][MAX], int node_n)
{//对暴力进行优化Floyd
	for (int i = 0; i < node_n; i++)
		for (int j = 0; j < node_n; j++)
			for (int k = 0; k < node_n; k++)
			{
				if (length[j][i] == maxlen || length[i][k] == maxlen) continue;
					if (length[j][k] == maxlen || length[j][k] < length[j][i] + length[i][k])
						length[j][k] = length[j][i] + length[i][k];
			}
}
void RollFloyd(unsigned length[][MAX], int node_n)
{//利用滚动数组进行优化
	unsigned f[MAX][MAX][MAX];
	for (int i = 0; i < node_n; i++)
	{
		for (int j = 0; j < node_n; j++)
		{
			for (int k = 0; k < node_n; k++)
				if (i != j) f[k][i][j] = maxlen;
			f[0][i][j] = length[i][j];
		}
	}
	for (int k = 1; k <= node_n; k++)
		for (int i = 0; i < node_n; i++)
			for (int j = 0; j < node_n; j++)
				f[k][i][j] = min(f[k - 1][i][j], f[k - 1][i][k - 1] + f[k - 1][k - 1][j]);
	for (int i = 0; i < node_n; i++)
		for (int j = 0; j < node_n; j++)
			length[i][j] = f[node_n][i][j];
}

三、拓扑排序

例题

9 12
0 1 6
0 2 4
0 3 5
1 4 1
2 4 1
3 5 2
5 4 0
4 6 9
4 7 7
5 7 4
6 8 2
7 8 4

#include <cstdio>
#include <algorithm>
#define MAX 105

using namespace std;

int mp[MAX][MAX];//图
int in[MAX];//前继数
int q[MAX];//0前继结点
int dis[MAX];//距离记录
int maxt=0;//最大 最早发生时间

int main() 
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            mp[i][j] = -1;
    for (int i = 0; i < m; i++) 
    {//更新图
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        mp[a][b] = c;
        in[b]++;//记录节点的前继数量
    }
    int head = 0, tail = 0;
    for (int i = 0; i < n; i++) 
        if (!in[i]) 
            q[tail++] = i;//获得一开始无前继的结点
    while (head < tail) 
    {//预留tail做有环判断
        int d = q[head++];//查看入度为0的结点
        maxt = max(maxt, dis[d]);
        for (int i = 0; i < n; i++) 
        {//遍历查找入度为0的孩子结点
            if (mp[d][i] != -1) 
            {
                dis[i] = max(dis[i], dis[d] + mp[d][i]);//已存dis和 正在查看的路所计算的dis
                if (!(--in[i]))//减少孩子结点的入度 并判断入度是否为0
                    q[tail++] = i;
            }
        }
    }
    if (tail < n) 
        printf("Impossible");
    else
        printf("%d\n", maxt);
    return 0;
}

四、关键路径

例题

7 8
1 2 4
1 3 3
2 4 5
3 4 3
4 5 1
4 6 6
5 7 5
6 7 2

样例

#include <cstdio>
#include <algorithm>
#define inf 0x3f3f3f3f

using namespace std;

int n, m, head, tail;
int mp[105][105], maxt;
int in[105], out[105], ve[105], vl[105], q[105];

int getve()
{ //计算 所有结点 前继结点ve+所连接的权 的最大值
    head = tail = 0;//(h21 h17h29 h33)
    for (int i = 1; i <= n; i++)
    {//遍历查找入度为0的结点并置入数组为遍历(h21)做准备
        if (!in[i])
            q[tail++] = i;
    }
    while (head < tail)
    {
        int d = q[head++];//查看入度为0的结点
        maxt = max(maxt, ve[d]);//记录整个项目的最大ve 为计算最晚准备(h42)
        for (int i = 1; i <= n; i++)
        {//遍历查找入度为0的孩子结点
            if (mp[d][i])
            {//最早发生时间 ve
                ve[i] = max(ve[i], ve[d] + mp[d][i]);//已存ve和 正在查看的路所计算的ve
                if (!(--in[i]))//减少孩子结点的入度 并判断入度是否为0
                    q[tail++] = i;
            }
        }
    }
    return tail == n;//tail记录了加入的结点数量 
}
void getvl()
{ //计算 所有结点 本结点vl-前继结点权重 的最小值
    head = tail = 0;
    for (int i = 1; i <= n; i++)
    {//遍历查找出度为0的结点并置入数组为遍历(h46)做准备
        if (!out[i])
            q[tail++] = i;
        vl[i] = maxt; //初始化为最早开始的最大时间(h51)
    }
    while (head < tail)
    {
        int d = q[head++];//查看出度为0的结点
        for (int i = 1; i <= n; i++)
        {//遍历查找出度为0的父结点
            if (mp[i][d])
            {//最迟发生时间 vl
                vl[i] = min(vl[i], vl[d] - mp[i][d]);//已存vl和 正在查看的路所计算的vl
                if (!(--out[i]))//减少父结点的入度 并判断出度是否为0
                    q[tail++] = i;
            }
        }
    }
}
void solve()
{
    for (int i = 1; i <= n; i++)
    {
        if (ve[i] != vl[i])
            continue;
        for (int j = n; j >= 1; j--)
        { //逆序
            if (mp[i][j] && ve[j] == vl[j] && vl[j] == ve[i] + mp[i][j])
            {
                printf("%d->%d\n", i, j);
            }
        }
    }
}
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        mp[a][b] = c;//记录边权
        out[a]++;//记录a的出度
        in[b]++;//记录b的入度
    }
    if (!getve())
        printf("0");
    else
    {
        printf("%d\n", maxt);
        getvl();
        solve();
    }
    return 0;
}
G_A0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串匹配算法————数据结构//复习复习
m0_46154875的博客
06-04 69
现复习BF算法及KMP算法 其他算法待 KMP思路理解推荐
红黑、B、B+————数据结构//复习复习复习
m0_46154875的博客
07-10 125
其他树的增删查都如此 查找效率最高 但维护成本高 继承了平衡二叉树的高查找效率 但继承不多 维护成本变低 为了减少判断 即减少磁盘存取次数 在单位内存为了获得更多的数据存储
数据结构与算法期末复习——知识点+题库
软件手的博客
05-12 9057
大学生 数据结构期末复习——知识点+题库 四川轻化工
数据结构复习3：图算法实现常考点
Joye-joy的博客
12-18 439
在算法实现方面要求，熟练掌握图的两种遍历方法， DFSTraverse(G, v, Visit()); //从顶点v起深度优先遍历图G，并对每个顶点调用函数Visit一次且仅一次。 void DFS( ALGraph *G , int v )//用邻接表实现，遍历图G中与顶点v相连的顶点 { LinkNode *p ; Visited[v] = TRUE ; // 置访问标志，...
数据结构算法复习3：图相关考点
Joye-joy的博客
11-21 1189
图相关算法总结
全国计算机专业专科生专升本复习资料——数据结构.zip
08-15
本复习资料集合了全国计算机专业专科生专升本考试中关于数据结构的重要知识点，旨在帮助考生全面理解并熟练运用各类数据结构，提高解题能力。 1. **数组**：数组是最基础的数据结构，它提供了按索引访问元素的能力...
数据结构复习要点知识点总结笔记(整理版).doc
06-11
### 数据结构复习要点知识点总结 #### 一、数据结构概述 **1. 数据**: 在计算机科学领域中，数据指的是能够被计算机程序处理的各种符号的集合。这些符号包括但不限于数字、字母、图像等。 **2. 数据元素**: 数据...
xianligongdaxue——————863数据结构
12-17
863数据结构复习题重点涵盖了数据结构的基本概念、逻辑结构、存储结构、算法分析和评价。 1. **数据结构基本概念**： - **数据元素**：构成数据的基本单位，比如数组中的一个数或链表中的一个节点。 - **数据项**...
题数据结构复习题_ch.pdf
06-28
本题集主要涉及两个基本的数据结构——栈和队列，以及它们的操作。 栈是一种后进先出（LIFO）的数据结构，常用于表达式求解、递归等场景。题目中提到了链式栈的操作。在链式栈中，插入新节点（入栈）的操作是将新...
数据结构——期末复习.ppt
07-11
以上是数据结构复习中常见的主题。对于算法时间复杂度的计算，可以通过简化和归纳基本操作的执行次数来确定其大O阶。例如，例1中的求和算法时间复杂度为O(n)，因为其基本操作（累加）的次数与输入规模n成正比。例2中...
图解大顶堆的构建、排序过程
sagima_sdu的博客
08-12 496
开始，
排序算法之桶排序
rd_w_csdn的博客
08-12 815
桶排序（bucket sort）是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
备战秋招60天算法挑战，Day17
溜达虎的博客
08-13 365
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
算法：魔法字典
Garson的博客
08-12 547
设计一个使用单词列表进行初始化的数据结构，单词列表中的单词。如果给出一个单词，请判定能否只将这个单词中字母换成另一个字母，使得所形成的新单词存在于你构建的字典中。实现dictionarydictionarysearchWordtruefalse// 返回 False// 将第二个 'h' 替换为 'e' 可以匹配 "hello" ，所以返回 True// 返回 False// 返回 FalsedictionarybuildDictsearch100search。
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 660
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
数据结构——排序（4）：归并排序+计数排序
2301_81888634的博客
08-16 606
至此我们学习了顺序表、链表、栈、队列、二叉树、排序，初阶数据结构完结~撒花！我们C++见！！
代码随想录算法训练营第十七天
b1ankwall的博客
08-16 571
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【Python】生成二维迷宫的算法
最新发布
HarryXYC的博客
08-16 163
基于Pygame和PIL的迷宫生成器
算法之递归和迭代
qq_28576837的博客
08-16 131
斐波那契数列（Fibonacci sequence），又称黄金分割数列，这个数列最早是由印度数学家提出来的。如果是用迭代，那么就是用循环从前往后计算，前两个数是固定的，先根据前两个数可以计算出第三个数，然后把第三个数和第二个数再赋值给之前的变量，再相加即可。使用递归时，如果要计算第100个数，那么要先直到第99和第98个，要知道第99个和第98个，就要分别进行递归，直到最后一层，再返回递归回来进行计算。这个序列的前几项是这样的：0,1,1,2,3,5,8,13,21,34,⋯。自然，用递归函数最容易实现。
C++编程：期末复习——数据结构与算法详解
本资源是一份关于数据结构与算法期末复习的PPT，由陈刚老师制作，适用于武汉大学国际软件学院的学生。内容覆盖了C++语言在数据结构和算法教学中的关键部分。首先，PPT从C++语言基础出发，介绍了函数原型，强调了函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值