算法学习——图论（一）

已于 2024-07-18 22:06:01 修改
阅读量595 收藏 12
点赞数 11
文章标签： 算法 学习 图论
于 2024-07-17 17:37:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lei453913232/article/details/140491105
版权

目录

一、存储矩阵的两种方式

1、邻接矩阵

2、邻接表

二、所有可能的路径（深搜基础）

1、核心代码模式

2、ACM模式（邻接矩阵）

3、ACM模式（邻接表）

三、岛屿数量

1、深度优先搜索

2、广度优先搜索

3、并查集

四、岛屿的最大面积

1、深度优先搜索

2、广度优先搜索

一、存储矩阵的两种方式

        输入示例一：

        第一行包含两个整数 N，M，表示图中拥有 N 个节点，M 条边

        后续 M 行，每行包含两个整数 s 和 t，表示图中的 s 节点与 t 节点中有一条路径

5 5
1 3
3 5
1 2
2 4
4 5

        输入示例二：

        第一行包含两个整数 N, M，表示矩阵的行数和列数。

        后续 N 行，每行包含 M 个数字，数字为 1 或者 0。

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

1、邻接矩阵

        邻接矩阵使用二维数组来表示图结构。 邻接矩阵是从节点的角度来表示图，有多少节点就申请多大的二维数组。

        例如： grid[2][5] = 6，表示节点 2 连接节点 5 为有向图，节点 2 指向节点 5，边的权值为 6。

        如果想表示无向图，即：grid[2][5] = 6，grid[5][2] = 6，表示节点 2 与节点 5 相互连通，权值为 6。

        ACM模式输入邻接矩阵（对应示例一）：

int N, M;
cin >> N >> M;
vector<vector<int>> graph(N, vector<int>(N, 0));
int s, t;
for (int i = 0; i < M; i++)
{
	cin >> s >> t;
	graph[s][t] = 1;
}

        ACM模式输入邻接矩阵（对应示例二）：

int N, M;
cin >> N >> M;
vector<vector<int>> graph(N, vector<int>(M, 0));
for (int i = 0; i < N; i++)
{
	for (int j = 0; j < M; j++)
	{
		cin >> graph[i][j];
	}
}

2、邻接表

        邻接表使用数组 + 链表的方式来表示。邻接表是从边的数量来表示图，有多少边才会申请对应大小的链表。

        ACM模式输入邻接表（对应示例一）：

int N, M;
cin >> N >> M;
vector<list<int>> graph(N);
int s, t;
for (int i = 0; i < M; i++)
{
	cin >> s >> t;
	graph[s].push_back(t);
}

二、所有可能的路径（深搜基础）

        原题力扣797        . - 力扣（LeetCode）

1、核心代码模式

vector<vector<int>> result;
vector<int> path;
void dfs(vector<vector<int>>& graph, int curNode, int n)
{
    if (curNode == n - 1) // 终止条件：找到目标节点
    {
        result.push_back(path); // 保存结果
        return;
    }
    for (int i = 0; i < graph[curNode].size(); i++)
    {
        path.push_back(graph[curNode][i]); // 保存至路径
        dfs(graph, graph[curNode][i], n); // 进入下一层
        path.pop_back(); // 回溯
    }
}
vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph)
{
    int n = graph.size();
    path.push_back(0);
    dfs(graph, 0, n);
    return result;
}

2、ACM模式（邻接矩阵）

#include <iostream>
#include <vector>
using namespace std;

vector<vector<int>> result;
vector<int> path;
void dfs(vector<vector<int>>& graph, int curNode, int n)
{
	if (curNode == n - 1)
	{
		result.push_back(path);
		return;
	}
	for (int i = 0; i < n; i++)
	{
		if (graph[curNode][i] == 1)
		{
			path.push_back(i);
			dfs(graph, i, n);
			path.pop_back();
		}
	}
}

int main()
{
	int N, M;
	cin >> N >> M;
	vector<vector<int>> graph(N, vector<int>(N, 0));
	int s, t;
	for (int i = 0; i < M; i++)
	{
		cin >> s >> t;
		graph[s][t] = 1;
	}
	path.push_back(1);
	dfs(graph, 1, N);
	if (result.size() == 0)
	{
		cout << -1 << endl;
	}
	for (int i = 0; i < result.size(); i++)
	{
		for (int j = 0; j < result[i].size(); j++)
		{
			cout << result[i][j];
			if (j != result[i].size() - 1)
			{
				cout << " ";
			}
		}
		cout << endl;
	}
	return 0;
}

3、ACM模式（邻接表）

#include <iostream>
#include <vector>
#include <list>
using namespace std;

vector<vector<int>> result;
vector<int> path;
void dfs(vector<list<int>>& graph, int curNode, int n)
{
	if (curNode == n - 1)
	{
		result.push_back(path);
		return;
	}
	for (int x : graph[curNode])
	{
		path.push_back(x);
		dfs(graph, x, n);
		path.pop_back();
	}
}

int main()
{
	int N, M;
	cin >> N >> M;
	vector<list<int>> graph(N);
	int s, t;
	for (int i = 0; i < M; i++)
	{
		cin >> s >> t;
		graph[s].push_back(t);
	}
	path.push_back(1);
	dfs(graph, 1, N);
	if (result.size() == 0)
	{
		cout << -1 << endl;
	}
	for (int i = 0; i < result.size(); i++)
	{
		for (int j = 0; j < result[i].size(); j++)
		{
			cout << result[i][j];
			if (j != result[i].size() - 1)
			{
				cout << " ";
			}
		}
		cout << endl;
	}
	return 0;
}

三、岛屿数量

        原题力扣200        . - 力扣（LeetCode）

1、深度优先搜索

int dirs[4][2] = { {0, 1}, {1, 0}, {0, -1}, {-1, 0} };
void dfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y, int n, int m)
{
    for (const auto& dir : dirs)
    {
        int nextX = x + dir[0];
        int nextY = y + dir[1];
        if (nextX >= n || nextX < 0 || nextY >= m || nextY < 0)
        {
            continue;
        }
        if (!visited[nextX][nextY] && grid[nextX][nextY] == '1')
        {
            visited[nextX][nextY] = true;
            dfs(grid, visited, nextX, nextY, n, m);
        }
    }
}
int numIslands(vector<vector<char>>& grid)
{
    int n = grid.size();
    int m = grid[0].size();
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    int ans = 0;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (!visited[i][j] && grid[i][j] == '1')
            {
                visited[i][j] = true;
                ans++;
                dfs(grid, visited, i, j, n, m);
            }
        }
    }
    return ans;
}

2、广度优先搜索

int dirs[4][2] = { {0, 1}, {1, 0}, {0, -1}, {-1, 0} };
void bfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y, int n, int m)
{
	queue<pair<int, int>> que;
	que.push({ x, y });
	visited[x][y] = true;
	while (!que.empty())
	{
		pair<int, int> curNode = que.front();
		que.pop();
		for (const auto& dir : dirs)
		{
			int nextX = curNode.first + dir[0];
			int nextY = curNode.second + dir[1];
			if (nextX >= n || nextX < 0 || nextY >= m || nextY < 0)
			{
				continue;
			}
			if (!visited[nextX][nextY] && grid[nextX][nextY] == '1')
			{
				que.push({ nextX, nextY });
				visited[nextX][nextY] = true;
			}
		}
	}
}
int numIslands(vector<vector<char>>& grid)
{
	int n = grid.size();
	int m = grid[0].size();
	vector<vector<bool>> visited(n, vector<bool>(m, false));
	int ans = 0;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (!visited[i][j] && grid[i][j] == '1')
			{
				ans++;
				bfs(grid, visited, i, j, n, m);
			}
		}
	}
	return ans;
}

3、并查集

四、岛屿的最大面积

        原题力扣695        . - 力扣（LeetCode）

1、深度优先搜索

int dirs[4][2] = { {0, 1}, {1, 0}, {0, -1}, {-1, 0} };
int count;
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y, int n, int m)
{
	for (const auto& dir : dirs)
	{
		int nextX = x + dir[0];
		int nextY = y + dir[1];
		if (nextX >= n || nextX < 0 || nextY >= m || nextY < 0)
		{
			continue;
		}
		if (!visited[nextX][nextY] && grid[nextX][nextY] == 1)
		{
			visited[nextX][nextY] = true;
			count++; // 找到新的陆地格，计数器加1
			dfs(grid, visited, nextX, nextY, n, m);
		}
	}
}
int maxAreaOfIsland(vector<vector<int>>& grid)
{
	int n = grid.size();
	int m = grid[0].size();
	vector<vector<bool>> visited(n, vector<bool>(m, false));
	int ans = 0;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (!visited[i][j] && grid[i][j] == 1)
			{
				count = 1; // 找到新的岛，重置计数器
				visited[i][j] = true;
				dfs(grid, visited, i, j, n, m);
				ans = max(ans, count);
			}
		}
	}
	return ans;
}

2、广度优先搜索

int dirs[4][2] = { {0, 1}, {1, 0}, {0, -1}, {-1, 0} };
int count;
void bfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y, int n, int m)
{
	queue<pair<int, int>> que;
	que.push({ x, y });
	visited[x][y] = true;
	while (!que.empty())
	{
		pair<int, int> curNode = que.front();
		que.pop();
		for (const auto& dir : dirs)
		{
			int nextX = curNode.first + dir[0];
			int nextY = curNode.second + dir[1];
			if (nextX >= n || nextX < 0 || nextY >= m || nextY < 0)
			{
				continue;
			}
			if (!visited[nextX][nextY] && grid[nextX][nextY] == 1)
			{
				que.push({ nextX, nextY });
				count++; // 找到新的陆地格，计数器加1
				visited[nextX][nextY] = true;
			}
		}
	}
}
int maxAreaOfIsland(vector<vector<int>>& grid)
{
	int n = grid.size();
	int m = grid[0].size();
	vector<vector<bool>> visited(n, vector<bool>(m, false));
	int ans = 0;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (!visited[i][j] && grid[i][j] == 1)
			{
				count = 1; // 找到新的岛，重置计数器
				bfs(grid, visited, i, j, n, m);
				ans = max(ans, count);
			}
		}
	}
	return ans;
}

五、孤岛的总面积

        原题卡码网101        101. 孤岛的总面积

        先遍历图的四周运行一次dfs，把所有不是孤岛的陆地都置为0，再遍历全图求孤岛面积

1、深度优先搜索

#include <iostream>
#include <vector>
using namespace std;

int dirs[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
int count;
void dfs(vector<vector<int>>& graph, int x, int y, int n, int m)
{
	graph[x][y] = 0;
	count++;
	for (const auto& dir : dirs)
	{
		int nextX = x + dir[0];
		int nextY = y + dir[1];
		if (nextX >= n || nextX < 0 || nextY >= m || nextY < 0)
		{
			continue;
		}
		if (graph[nextX][nextY] == 0)
		{
			continue;
		}
		dfs(graph, nextX, nextY, n, m);
	}
}
int main()
{
	int N, M;
	cin >> N >> M;
	vector<vector<int>> graph(N, vector<int>(M, 0));
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			cin >> graph[i][j];
		}
	}
	for (int i = 0; i < N; i++)
	{
		if (graph[i][0] == 1)
		{
			dfs(graph, i, 0, N, M);
		}
		if (graph[i][M - 1] == 1)
		{
			dfs(graph, i, M - 1, N, M);
		}
	}
	for (int j = 0; j < M; j++)
	{
		if (graph[0][j] == 1)
		{
			dfs(graph, 0, j, N, M);
		}
		if (graph[N - 1][j] == 1)
		{
			dfs(graph, N - 1, j, N, M);
		}
	}
	count = 0;
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			if (graph[i][j] == 1)
			{
				dfs(graph, i, j, N, M);
			}
		}
	}
	cout << count << endl;
	return 0;
}

2、广度优先搜索

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

int dirs[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
int count;
void bfs(vector<vector<int>>& graph, int x, int y, int n, int m)
{
	queue<pair<int, int>> que;
	que.push({ x,y });
	graph[x][y] = 0;
	count++;
	while (!que.empty())
	{
		pair<int, int> curNode = que.front();
		que.pop();
		for (const auto& dir : dirs)
		{
			int nextX = curNode.first + dir[0];
			int nextY = curNode.second + dir[1];
			if (nextX >= n || nextX < 0 || nextY >= m || nextY < 0)
			{
				continue;
			}
			if (graph[nextX][nextY] == 0)
			{
				continue;
			}
			que.push({ nextX,nextY });
			count++;
			graph[nextX][nextY] = 0;
		}
	}
}
int main()
{
	int N, M;
	cin >> N >> M;
	vector<vector<int>> graph(N, vector<int>(M, 0));
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			cin >> graph[i][j];
		}
	}
	for (int i = 0; i < N; i++)
	{
		if (graph[i][0] == 1)
		{
			bfs(graph, i, 0, N, M);
		}
		if (graph[i][M - 1] == 1)
		{
			bfs(graph, i, M - 1, N, M);
		}
	}
	for (int j = 0; j < M; j++)
	{
		if (graph[0][j] == 1)
		{
			bfs(graph, 0, j, N, M);
		}
		if (graph[N - 1][j] == 1)
		{
			bfs(graph, N - 1, j, N, M);
		}
	}
	count = 0;
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			if (graph[i][j] == 1)
			{
				bfs(graph, i, j, N, M);
			}
		}
	}
	cout << count << endl;
	return 0;
}

lei453913232
关注
  • 11
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法学习：图论
曹老师
10-20 450
1
算法-图论
pourtheworld的博客
04-17 839
算法-图论图论强联通分量1. 2021-4-6 tarjan算法最短路径1. 2021-4-1 dijsktra最短路径最大值二分图1. 2021-3-31 二分图最大匹配2. 2021-4-1 二分图最小点覆盖 图论 强联通分量 1. 2021-4-6 tarjan算法 题目： 在一次聚会中，教授们被要求写下自己认可哪位教授的学术成果（也可以写自己，且可能出现重复）。已知，如果教授 A 认可教授 B ，且教授 B 认可教授 C，那么即可视为教授 A 也认可教授 C。现在我们想知道有多少对教授是两两互相认可
Tarjan 算法——图论学习笔记
pyy_official的博客
01-10 2403
Tarjan 算法在图论问题中有大用，特别是有关联通性的题。写字不易，给个赞吧~
C++学习笔记——图论
z0816208的博客
04-05 1315
图是由组成的，把图记作二元组G=（v，e）
七桥问题c语言程序数据结构,数据结构与算法学习——图论
weixin_33575588的博客
05-18 706
什么是图？在计算机程序设计中，图结构也是一种非常常见的数据结构但是图论其实是一个非常大的话题图结构是一种与树结构有些相似的数据结构图论是数学的一个分支，并且在数学概念上，树是图的一种它以图为研究对象，研究顶点和边组成的图形的数学理论和方法主要研究的目的是事务之间的关系，定点代表事务，边代表两个事物间的关系图的现实案例人与人之间的关系网甚至科学家们在观察人与人之间的关系网时，还发现了六度空间理论六度...
数学建模算法模型——图论排队论.zip
10-10
《数学建模算法模型——图论排队论》 在信息技术领域，数学建模是一种至关重要的方法，它将现实世界的问题转化为数学模型，以便通过计算和分析来解决问题。本压缩包包含了一系列关于数学建模中图论和排队论的资料，...
算法学习模板——图论中的最短路径问题
qq_54389628的博客
08-12 584
包含了dijkstra和floyd算法，解决图论的最短路相关问题。
离散数学——图论PPT学习教案.pptx
10-10
**离散数学——图论** 图论是离散数学的一个重要组成部分，它的研究对象是图形，即由点和连接这些点的线所组成的结构。这个领域起源于18世纪，瑞士数学家欧拉在解决“哥尼斯堡七桥问题”时提出了一种新的数学思维，...
数据结构——图论
02-06
在这个“数据结构——图论”的压缩包中，我们很显然会探讨图的相关概念以及一种重要的算法——Dijkstra算法，特别是在邻接表的实现上。 首先，让我们了解什么是图。在计算机科学中，图是由一组顶点（或节点）和连接...
离散数学——图论PPT课件.pptx
10-09
离散数学——图论PPT课件 本资源是关于图论的PPT课件，涵盖了图论的基本概念、历史发展、应用领域等多方面的知识点。下面是对资源的详细解读： 一、图论的历史发展 图论是一个古老而又年轻的数学分支，它诞生于 ...
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 371
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
递归、搜索与回溯算法
无聊_人的博客
08-29 3416
所谓的递归其实就是函数自己调用自己的情况。
代码随想录算法训练营第62天|Floyd 算法精讲、A * 算法精讲 （A star算法）
Yinems的博客
08-28 1248
分两种情况，一种是节点 i 到节点 j 的最短路径经过节点 k，grid[i][j][k] = grid[i][k][k-1] + grid[k][j][k-1]；另一种情况，节点 i 到节点 j 的最短路径不经过节点 k，grid[i][j][k] = grip[i][j][k-1]；刚开始初始化 k 是不确定的，如果赋值为1，那么不能知道节点 i 到节点 j 经过1个节点的最短距离，所以只能把 k 赋值为0，本题中节点0是无意义的，节点是从1到n。本题求的是最小值，所以其余值初始化为最大值。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 3720
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
精选算法编程题
A18937260063的博客
08-30 308
数组编程
深度学习（DL）算法分分类
m0_46171719的博客
08-28 479
深度学习（DL）算法是机器学习的一个子集，专注于使用深度神经网络（DNN）来模拟人脑的学习过程，从而解决复杂的数据处理和模式识别问题。
[E二叉树] lc110. 平衡二叉树(dfs+自底向上)
Y-puyu 的博客
08-31 156
【代码】[E二叉树] lc110. 平衡二叉树(dfs+自底向上)
算法的学习笔记—把数字翻译成字符串
最新发布
业精于勤，荒于嬉
08-31 530
通过动态规划的方法，我们可以高效地计算出一个数字字符串有多少种不同的翻译方法。这个问题不仅考察了我们对动态规划的理解，还让我们熟悉了如何处理字符串中的边界情况和状态转移。希望通过这个例子的讲解，能够帮助你更好地理解动态规划的应用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybit欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论
冒泡排序算法
m0_74051652的博客
08-28 1238
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止，这意味着数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（或说是排序的开头位置），就如同水中的气泡一样上升到水面。冒泡排序的写法可以简单分为两种方式，分别是：前同后异、前异后同。
平面图与非平面图的概念及应用——图论算法解析
"一本很好的图论算法书" 平面图与非平面图是图论中的核心概念，它们在诸如网络设计、电路布局、地图绘制等领域有着广泛的应用。平面图是指能够在平面上绘制，使得任意两条边都不相交的图，而无法避免边交叉的图则被...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值