图的生成树与生成森林

最新推荐文章于 2024-07-25 11:05:03 发布
最新推荐文章于 2024-07-25 11:05:03 发布
阅读量2.7k 收藏 19
点赞数 19
分类专栏： 数据结构 文章标签： 图论 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61433144/article/details/128585072
版权

文章目录

连通图与连通分量

在无向图中, 若从顶点v到顶点w有路径存在, 则称v和w是连通的. 若图G中任意两个顶点都是连通的, 则称图G为连通图, 否则称为非连通图. 无向图中的极大连通子图称为连通分量, 在图(a)中, 图G有3个连通分量如图(b)所示.

假设一个图有n个顶点, 如果边数小于n-1, 那么此图必是非连通图. 如果图是非连通图, 那么最多可以有多少条边?

image-20230106170643111

强连通图与强连通分量

在有向图中, 如果有一对顶点v和w, 从v到w和从w到v之间都有路径, 则称这两个顶点是强连通的. 若图中任何一对顶点都是强连通的, 则称此图为强连通图. 有向图中的极大强连通子图称为有向图的强连通分量, 图G的强连通分量如图(b)所示。

假设一个有向图有n个顶点, 如果是强连通图, 那么最少需要有多少条边.

image-20230106172402815

图的连通性判断

图的遍历算法可以用来判断图的连通性.

对于无向图来说, 若无向图是连通的, 则从任一结点出发, 仅需一次遍历就能够访问图中的所有顶点; 若无向图是非连通的, 则从某一个顶点出发, 一次遍历只能访问到该顶点所在连通分量的所有顶点, 而对于图中其他连通分量的顶点, 则无法通过这次遍历访问.

对于有向图来说, 若从某一顶点到图中的每个顶点都有路径, 则能够访问到图中的所有顶点, 否则不能访问到所有顶点. 因此判断有向图的强连通性, 需要依次从所有顶点出发遍历, 只有从所有顶点出发遍历到其它所有顶点, 该有向图才具有强连通性, 如果从某一个顶点出发遍历, 不能连续遍历到其它顶点, 则该有向图不具有强连通性.

邻接表

		bool _IsConnected(int srci)
		{
			int n = static_cast<int>(_vertexSet.size());

			vector<bool> markbit(n, false);

			queue<int> q;
			q.push(srci);
			markbit[srci] = true;
			// 类似广度优先遍历的思想
			while (!q.empty())
			{
				auto front = q.front();
				q.pop();

				Edge* curr = _table[front];

				while (curr != nullptr)
				{
					if (!markbit[curr->_dsti])
					{
						q.push(curr->_dsti);
						markbit[curr->_dsti] = true;
					}
					curr = curr->_next;
				}
			}
			// 如果还有顶点没有遍历到,说明不是连通图
			for (int i = 0; i < n; i++)
			{
				if (!markbit[i])
				{
					return false;
				}
			}

			return true;
		}

		bool IsConnected()
		{
			if (_vertexSet.empty())
				return true;

			if (Directed) // 有向图的强连通性判断
			{
				int n = static_cast<int>(_vertexSet.size());
				// 需要依次从所有顶点出发遍历
				for (int i = 0; i < n; i++)
				{
					if (!_IsConnected(i))
					{
						return false;
					}
				}

				return true;
			}
			else // 无向图的连通性判断
			{
				return _IsConnected(0);
			}
		}

邻接矩阵

		bool _IsConnected(int srci)
		{
			int n = static_cast<int>(_vertexSet.size());

			vector<bool> markbit(n, false);

			queue<int> q;
			q.push(srci);
			markbit[srci] = true;

			while (!q.empty())
			{
				auto front = q.front();
				q.pop();

				for (int i = 0; i < n; i++)
				{
					if (_matrix[front][i] != W_MAX && !markbit[i])
					{
						q.push(i);
						markbit[i] = true;
					}
				}
			}

			for (int i = 0; i < n; i++)
			{
				if (!markbit[i])
				{
					return false;
				}
			}

			return true;
		}

		bool IsConnected()
		{
			if (_vertexSet.empty())
				return false;

			if (Directed)
			{
				int n = static_cast<int>(_vertexSet.size());

				for (int i = 0; i < n; i++)
				{
					if (!_IsConnected(i))
					{
						return false;
					}
				}

				return true;
			}
			else
			{
				return _IsConnected(0);
			}
		}

生成树

一个连通图的生成树是一个极小连通子图, 它含有图中全部n个顶点, 但只有足以构成一棵树的n-1条边. 在生成树中添加一条边之后, 必然会形成回路/环. 一般来说, 一个连通图的生成树并不是唯一的, 除非原图本身就是一棵树.

image-20230106172904827

深度优先生成树

采用DFS算法遍历图所得到的生成树称为深度优先生成树.

邻接表

image-20230106190130787

image-20230106185955661

邻接矩阵

image-20230106184009105

image-20230106185654288

广度优先生成树

采用BFS算法遍历图所得到的生成树称为广度优先生成树.

邻接表

image-20230106203533536

image-20230106203430722

邻接矩阵

image-20230106202923949

image-20230106195948832

生成森林

若无向图G是非连通图, 从图中某一顶点出发遍历图, 不能访问到该图的所有顶点, 需要依次对图中的每一个连通分量进行深度优先遍历或者广度优先遍历, 即需要从多个顶点出发进行DFS或者BFS.

在遍历过程中, 如果将每次前进途中路过的顶点与边记录下来, 将会得到多棵树, 从而构成森林.

  • 采用DFS算法遍历图所得到的生成森林称为广度优先生成森林.
  • 采用BFS算法遍历图所得到的生成森林称为广度优先生成森林.

image-20230106204243884

获取边弧的权值

邻接表

		// 获取两个相连顶点之间边的权值
		const W& GetEdgeWeight(const V& src, const V& dst)
		{
			int srci = GetVertexIndex(src);
			int dsti = GetVertexIndex(dst);

			if (srci == -1 || dsti == -1)
			{
				return W(); // 可以选择抛异常
			}

			Edge* curr = _table[srci];

			while (curr!=nullptr)
			{
				if (curr->_dsti == dsti)
				{
					return curr->_weight;
				}
				curr=curr->_next;
			}

			return W();
		}

邻接矩阵

		// 获取两个相连顶点之间边的权值
		const W& GetEdgeWeight(const V& src, const V& dst)
		{
			int srci = GetVertexIndex(src);
			int dsti = GetVertexIndex(dst);

			if (srci == -1 || dsti == -1)
			{
				return W(); // 可以选择抛异常
			}
			
			return _matrix[srci][dsti];
		}

源代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <queue>
#include <map>

using namespace std;

namespace AdjacentMatrix
{
	template<typename V, typename W, W W_MAX, bool Directed = false>
	class Graph
	{
	private:
		std::vector<V> _vertexSet;
		std::map<V, int> _vertexIndex;
		std::vector<std::vector<W>> _matrix;
	public:

		typedef Graph<V, W, W_MAX, Directed> Self;

		Graph() = default;

		int GetVertexIndex(const V& v)
		{
			typename std::map<V, int>::iterator pos = _vertexIndex.find(v);
			if (pos != _vertexIndex.end())
			{
				return pos->second;
			}
			else
			{
				return -1;
			}
		}

		// 获取两个相连顶点之间边的权值
		const W& GetEdgeWeight(const V& src, const V& dst)
		{
			int srci = GetVertexIndex(src);
			int dsti = GetVertexIndex(dst);

			if (srci == -1 || dsti == -1)
			{
				return W(); // 可以选择抛异常
			}
			
			return _matrix[srci][dsti];
		}

		bool AddVertex(const V& v)
		{
			// 顶点存在不需要继续增加
			if (GetVertexIndex(v) != -1)
				return false;

			_vertexSet.push_back(v);
			_vertexIndex.insert(std::make_pair(v, _vertexSet.size() - 1));

			// 先在原有的行上一列
			for (int i = 0; i < _matrix.size(); i++)
			{
				_matrix[i].push_back(W_MAX);
			}

			// 增加一行
			_matrix.push_back(std::vector<W>(_vertexSet.size(), W_MAX));

			return true;
		}

		bool AddEdge(const V& src, const V& dst, const W& weight)
		{
			int srci = GetVertexIndex(src);
			int dsti = GetVertexIndex(dst);

			// 顶点不在图中,添加边失败
			if (srci == -1 || dsti == -1)
				return false;

			_matrix[srci][dsti] = weight;

			// 如果为无向图,则需要再添加一条dst->src的边
			if (!Directed)
			{
				_matrix[dsti][srci] = weight;
			}

			return true;
		}

		bool bfsSpanningTree(Self& spanningTree, const V& src)
		{
			int srci = GetVertexIndex(src);

			// 遍历源点不存在,不能进行遍历
			if (srci == -1)
			{
				return false;
			}

			// 只有图为无向图且是连通图才能选出生成树
			if (Directed && !IsConnected())
				return false;
			// 将spanningTree拷贝成与当前图相同顶点的零图
			spanningTree._vertexSet = _vertexSet;
			spanningTree._vertexIndex = _vertexIndex;
			spanningTree._matrix.resize(_vertexSet.size(), vector<W>(_vertexSet.size(), W_MAX));

			vector<bool> visited(_vertexSet.size(), false);
			
			// pair.first是pair.second的上一层顶点下标
			queue<pair<int,int>> q;
			// 将遍历源点下标入队,并标记访问过
			q.push({-1,srci});
			visited[srci] = true;

			while (!q.empty())
			{
				pair<int,int> front = q.front();
				q.pop();

				int first = front.first; // 当前遍历顶点的上一层顶点
				int second = front.second; // 当前遍历顶点

				if (first != -1)
				{
					// 将选出的边添加到spanningTree中
					std::cout << _vertexSet[first] << "<--->" << _vertexSet[second] << std::endl;
					spanningTree.AddEdge(_vertexSet[first], _vertexSet[second], _matrix[first][second]);
				}

				// 将与front.second相连的顶点且没有被访问的顶点入队
				for (int i = 0; i < static_cast<int>(_vertexSet.size()); i++)
				{
					if (_matrix[second][i] != W_MAX && !visited[i])
					{
						// 入队之后标记访问过
						q.push({second,i});
						visited[i] = true; 
					}
				}
			}

			return spanningTree.IsConnected();
		}

		void _dfsSpanningTree(Self& spanningTree, int srci, int& previ, vector<bool>& visited)
		{
			if (previ != -1)
			{
				// 将选出的边添加到spanningTree中
				std::cout << _vertexSet[previ] << "<--->" << _vertexSet[srci] << std::endl;
				spanningTree.AddEdge(_vertexSet[previ], _vertexSet[srci],_matrix[previ][srci]);
			}
			// 标记访问过
			visited[srci] = true;
			// 更新前一个顶点的下标
			previ = srci; 
			// 与DFS遍历的思想相同
			for (int i = 0; i < static_cast<int>(_vertexSet.size()); i++)
			{
				if (_matrix[srci][i] != W_MAX && !visited[i])
				{
					_dfsSpanningTree(spanningTree, i, previ, visited);
				}
			}
			
		}

		bool dfsSpanningTree(Self& spanningTree, const V& src)
		{
			int srci = GetVertexIndex(src);

			// 遍历源点不存在,不能进行遍历
			if (srci == -1)
			{
				return false;
			}

			// 只有图为无向图且是连通图才能选出生成树
			if (Directed && !IsConnected())
				return false;
			// 将spanningTree拷贝成与当前图相同顶点的零图
			spanningTree._vertexSet = _vertexSet;
			spanningTree._vertexIndex = _vertexIndex;
			spanningTree._matrix.resize(_vertexSet.size(), vector<W>(_vertexSet.size(), W_MAX));

			vector<bool> visited(_vertexSet.size(), false);

			int previ = -1; // 遍历访问的前一个顶点下标

			_dfsSpanningTree(spanningTree, srci, previ, visited);

			return spanningTree.IsConnected(); // 如果spanningTree是连通图则说明构建生成树成功
		}

		bool _IsConnected(int srci)
		{
			int n = static_cast<int>(_vertexSet.size());

			vector<bool> markbit(n, false);

			queue<int> q;
			q.push(srci);
			markbit[srci] = true;

			while (!q.empty())
			{
				auto front = q.front();
				q.pop();

				for (int i = 0; i < n; i++)
				{
					if (_matrix[front][i] != W_MAX && !markbit[i])
					{
						q.push(i);
						markbit[i] = true;
					}
				}
			}

			for (int i = 0; i < n; i++)
			{
				if (!markbit[i])
				{
					return false;
				}
			}

			return true;
		}

		bool IsConnected()
		{
			if (_vertexSet.empty())
				return false;

			if (Directed)
			{
				int n = static_cast<int>(_vertexSet.size());

				for (int i = 0; i < n; i++)
				{
					if (!_IsConnected(i))
					{
						return false;
					}
				}

				return true;
			}
			else
			{
				return _IsConnected(0);
			}
		}

	};

	void TestMatrix3()
	{
		AdjacentMatrix::Graph<std::string, int, INT_MAX> g;

		g.AddVertex("A");
		g.AddVertex("B");
		g.AddVertex("C");
		g.AddVertex("D");
		g.AddVertex("E");
		g.AddVertex("F");
		g.AddVertex("G");

		g.AddEdge("A", "B", 1);
		g.AddEdge("A", "C", 1);
		g.AddEdge("B", "D", 1);
		g.AddEdge("B", "E", 1);
		g.AddEdge("C", "E", 1);
		g.AddEdge("C", "F", 1);
		g.AddEdge("D", "G", 1);
		g.AddEdge("E", "G", 1);
		g.AddEdge("F", "G", 1);

		AdjacentMatrix::Graph<std::string, int, INT_MAX> spanningTree;

		//g.dfsSpanningTree(spanningTree, "A");
		g.bfsSpanningTree(spanningTree, "A");

		std::cout << spanningTree.IsConnected() << std::endl;
	}

}

namespace AdjacentList
{
	template<typename W>
	struct Edge
	{
		int _dsti;
		W _weight;

		struct Edge<W>* _next;

		Edge(int dsti, const W& weight)
			:_dsti(dsti)
			, _weight(weight)
			, _next(nullptr)
		{}
	};

	template<typename V, typename W, bool Directed = false>
	class Graph
	{
		using Edge = Edge<W>;
	private:
		std::vector<V> _vertexSet; // 顶点的集合
		std::map<V, int> _vertexIndex; // 顶点映射下标
		std::vector<Edge*> _table; // 出度边表
	public:

		typedef Graph<V, W,Directed> Self;

		Graph() = default;

		int GetVertexIndex(const V& v)
		{
			typename std::map<V, int>::iterator pos = _vertexIndex.find(v);
			if (pos != _vertexIndex.end())
			{
				return pos->second;
			}
			else
			{
				return -1;
			}
		}

		bool AddVertex(const V& v)
		{
			if (GetVertexIndex(v) != -1)
				return false;

			_vertexSet.push_back(v);

			_vertexIndex.insert(std::make_pair(v, _vertexSet.size() - 1));

			_table.push_back(nullptr);

			return true;
		}

		bool AddEdge(const V& src, const V& dst, const W& weight)
		{
			int srci = GetVertexIndex(src);
			int dsti = GetVertexIndex(dst);

			// 顶点不在图中,添加边失败
			if (srci == -1 || dsti == -1)
				return false;

			Edge* edge = new Edge(dsti, weight);

			// 头插
			edge->_next = _table[srci];
			_table[srci] = edge;

			// 无向图
			if (!Directed)
			{
				edge = new Edge(srci, weight);

				edge->_next = _table[dsti];
				_table[dsti] = edge;
			}

			return true;
		}

		bool _IsConnected(int srci)
		{
			int n = static_cast<int>(_vertexSet.size());

			vector<bool> markbit(n, false);

			queue<int> q;
			q.push(srci);
			markbit[srci] = true;
			// 类似广度优先遍历的思想
			while (!q.empty())
			{
				auto front = q.front();
				q.pop();

				Edge* curr = _table[front];

				while (curr != nullptr)
				{
					if (!markbit[curr->_dsti])
					{
						q.push(curr->_dsti);
						markbit[curr->_dsti] = true;
					}
					curr = curr->_next;
				}
			}
			// 如果还有顶点没有遍历到,说明不是连通图
			for (int i = 0; i < n; i++)
			{
				if (!markbit[i])
				{
					return false;
				}
			}

			return true;
		}

		bool IsConnected()
		{
			if (_vertexSet.empty())
				return true;

			if (Directed) // 有向图的强连通性判断
			{
				int n = static_cast<int>(_vertexSet.size());
				// 需要依次从所有顶点出发遍历
				for (int i = 0; i < n; i++)
				{
					if (!_IsConnected(i))
					{
						return false;
					}
				}

				return true;
			}
			else // 无向图的连通性判断
			{
				return _IsConnected(0);
			}
		}

		// 获取两个相连顶点之间边的权值
		const W& GetEdgeWeight(const V& src, const V& dst)
		{
			int srci = GetVertexIndex(src);
			int dsti = GetVertexIndex(dst);

			if (srci == -1 || dsti == -1)
			{
				return W(); // 可以选择抛异常
			}

			Edge* curr = _table[srci];

			while (curr!=nullptr)
			{
				if (curr->_dsti == dsti)
				{
					return curr->_weight;
				}
				curr=curr->_next;
			}

			return W();
		}

		bool bfsSpanningTree(Self& spanningTree, const V& src)
		{
			int srci = GetVertexIndex(src);

			// 遍历源点不存在,不能进行遍历
			if (srci == -1)
			{
				return false;
			}

			// 只有图为无向图且是连通图才能选出生成树
			if (Directed && !IsConnected())
				return false;
			// 将spanningTree拷贝成与当前图相同顶点的零图
			spanningTree._vertexSet = _vertexSet;
			spanningTree._vertexIndex = _vertexIndex;
			spanningTree._table.resize(_vertexSet.size(), nullptr);

			vector<bool> visited(_vertexSet.size(), false);

			// pair.first是pair.second的上一层顶点下标
			queue<pair<int, int>> q;
			// 将遍历源点下标入队,并标记访问过
			q.push({ -1,srci });
			visited[srci] = true;

			while (!q.empty())
			{
				pair<int, int> front = q.front();
				q.pop();

				int first = front.first; // 当前遍历顶点的上一层顶点
				int second = front.second; // 当前遍历顶点

				if (first != -1)
				{
					// 将选出的边添加到spanningTree中
					std::cout << _vertexSet[first] << "<--->" << _vertexSet[second] << std::endl;
					spanningTree.AddEdge(_vertexSet[first], _vertexSet[second], 
						GetEdgeWeight(_vertexSet[first], _vertexSet[second]));
				}

				Edge* curr = _table[second];

				// 将与front.second相连的顶点且没有被访问的顶点入队
				while (curr != nullptr)
				{
					if (!visited[curr->_dsti])
					{
						q.push({ second,curr->_dsti });
						visited[curr->_dsti] = true;
					}

					curr = curr->_next;
				}
			}

			return spanningTree.IsConnected();
		}

		void _dfsSpanningTree(Self& spanningTree, int srci, int& previ, vector<bool>& visited)
		{
			if (previ != -1)
			{
				// 将选出的边添加到spanningTree中
				std::cout << _vertexSet[previ] << "<--->" << _vertexSet[srci] << std::endl;
				spanningTree.AddEdge(_vertexSet[previ], _vertexSet[srci], GetEdgeWeight(_vertexSet[previ], _vertexSet[srci]));
			}
			// 标记访问过
			visited[srci] = true;
			// 更新前一个顶点的下标
			previ = srci;

			Edge* curr = _table[srci];

			while (curr != nullptr)
			{
				if (!visited[curr->_dsti])
				{
					_dfsSpanningTree(spanningTree, curr->_dsti, previ, visited);
				}
				curr = curr->_next;
			}
		}
		// spanningTree为输出型参数,src为遍历源点
		bool dfsSpanningTree(Self& spanningTree, const V& src)
		{
			int srci = GetVertexIndex(src);

			// 遍历源点不存在,不能进行遍历
			if (srci == -1)
			{
				return false;
			}

			// 只有图为无向图且是连通图才能选出生成树
			if (Directed && !IsConnected())
				return false;
			// 将spanningTree拷贝成与当前图相同顶点的零图
			spanningTree._vertexSet = _vertexSet;
			spanningTree._vertexIndex = _vertexIndex;
			spanningTree._table.resize(_vertexSet.size(), nullptr);

			vector<bool> visited(_vertexSet.size(), false);

			int previ = -1; // 遍历访问的前一个顶点下标

			_dfsSpanningTree(spanningTree, srci, previ, visited);

			return spanningTree.IsConnected(); // 如果spanningTree是连通图则说明构建生成树成功
		}

	};

	void TestList3()
	{ 
		AdjacentList::Graph<std::string, int> g;

		g.AddVertex("A");
		g.AddVertex("B");
		g.AddVertex("C");
		g.AddVertex("D");
		g.AddVertex("E");
		g.AddVertex("F");
		g.AddVertex("G");

		g.AddEdge("A", "B", 1);
		g.AddEdge("A", "C", 1);
		g.AddEdge("B", "D", 1);
		g.AddEdge("B", "E", 1);
		g.AddEdge("C", "E", 1);
		g.AddEdge("C", "F", 1);
		g.AddEdge("D", "G", 1);
		g.AddEdge("E", "G", 1);
		g.AddEdge("F", "G", 1);

		AdjacentList::Graph<std::string, int> spanningTree;

		//g.dfsSpanningTree(spanningTree, "A");
		g.bfsSpanningTree(spanningTree, "A");

		std::cout << spanningTree.IsConnected() << std::endl;
	}
}


int main(int, char**, char**)
{

	AdjacentList::TestList3();
	//AdjacentMatrix::TestMatrix3();
	return 0;
}
羊羊羊三斤
关注
  • 19
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 35
    评论
专栏目录
深度优先生成树和广度优先生成树
数据结构和算法教程（C语言版）
04-15 4万+
本章的第一节中，介绍了有关生成树和生成森林的有关知识，本节来解决对于给定的无向图，如何构建它们相对应的生成树或者生成森林。 其实在对无向图进行遍历的时候，遍历过程中所经历过的图中的顶点和边的组合，就是图的生成树或者生成森林。 图 1 无向图 ...
数据结构-图的生成树问题
Peisenli的博客
08-28 5402
一、无向图的连通分量和生成树 若图是连通的或强连通的，则从图中某一个顶点出发可以访问到图中所有顶点； 若图是非连通的或非强连通图，则需从图中多个顶点出发搜索访问。而每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为每个连通分量中的顶点集。 1、生成树 深度优先搜索遍历算法及广度优先搜索遍历算法中遍历图过程中历经边的集合和顶点集合一起构成连通图的极小连通子图。它是连通图的一颗生成树。 生...
数据结构——图的连通性（生成树、最小生成树、生成森林）（Prim算法）（Kruskal算法）
Joshua Lee的博客
12-24 1万+
1、求图的生成树（或生成森林）       生成树：是一个极小连通子图，它含有图中全部n个顶点，但只有n-1条边。       生成森林： 由若干棵生成树组成，含全部顶点，但构成这些树的边是最少的。       深度优先搜索生成树： 由深度优先搜索得到的生成树       广度优先搜索生成树： 由广度优先搜索得到的生成树       若对连通图进行遍历，得到的是图的生成树       ...
图的生成树和最小生成树
热门推荐
优秀的判断力来自经验，但经验来自于错误的判断
11-26 3万+
一、生成树的概念                 在一个任意连通图G中，如果取它的全部顶点和一部分边构成一个子图G'，即：V（G'）=V（G）和E（G'）⊆E（G）         若同时满足边集E（G'）中的所有边既能够使全部顶点连通而又不形成任何回路，则称子图G'是原图G的一棵生成树。         下面简单说明一下，在既能够连通图G中的全部n个顶点又没有形成回路的子图G'（即
生成树和生成森林
Unique-You的博客
10-20 1万+
1、无向图的生成树和生成森林 对于无向连通图，在图的深度优先遍历或广度优先遍历过程中经历的边的集合和 图中的所有顶点一起构成图的极小连通子图，就是一颗生成树（深度优先生成树、广度优先生成树）。 对非连通无向图，深度优先搜索遍历或广度优先搜索遍历，每个连通分量中的顶点集合遍历时走过的边一起构成若干颗生成树，这些连通分量的生成树组成非连通图的生成森林（深度优先生成森林、广度优先生成森林）。 深度
（数据结构）生成树
weixin_51927215的博客
04-02 1万+
生成树 在连通图的基础上，本篇文章将介绍什么是生成树，以及什么是生成森林 先介绍生成树！！！ 对连通图进行遍历，过程中所经过的边和顶点的组合可看做是一棵普通树，通常称为生成树 图 1 连通图及其对应的生成树 图 1 中，左侧是一张连通图，右侧是其对应的 2 种生成树 但是介绍到这里我想疑问还是很多的，比如说遍历的方法是什么！生成树的定义是什么！ 遍历的方法：连通图中，通过任意两顶点之间可能含有多条通路进行遍历 图 1 中，右侧第一张生成树的遍历过程为或 ...
数据结构学习：图的最小生成树
weixin_45632016的博客
08-12 1398
数据结构学习：图的最小生成树 连通图的生成树是包含图中全部顶点的一个极小连通子图。 若图中顶点数为n，则它的生成树含有 n-1 条边。对生成树而言，若砍去它的一条边，则会变成非连通图，若加上一条边则会形成一个回路。 对于⼀个带权连通⽆向图G = (V, E)，⽣成树不同，每棵树的权（即树中所有边上的权值之和）也可能不同。设 R 为 G 的所有⽣成树的集合，若 T 为 R 中边的权值之和最⼩的⽣成树，则 T 称为 G 的最⼩⽣成树 最⼩⽣成树可能有多个，但边的权值之和总是唯⼀且最⼩的 最⼩⽣成树的边数 = 顶
计算机网络生成树算法,生成树算法
weixin_35964787的博客
06-26 1943
在图论的数学领域中，如果连通图G的一个子图是一棵包含G的所有顶点的树，则该子图称为G的生成树(SpanningTree)。生成树是连通图的包含图中的所有顶点的极小连通子图。图的生成树不惟一。从不同的顶点出发进行遍历，可以得到不同的生成树。常用的生成树算法有DFS生成树、BFS生成树、PRIM 最小生成树和Kruskal最小生成树算法。中文名生成树算法外文名Spanning tree algorit...
最小生成树基础与习题
weixin_43870697的博客
07-23 2756
目录 图的几个基础概念 Kruskal算法 算法思想 模板 Prim算法 算法思想 模板 例题 A.POJ-1251 Jungle Roads B.POJ-1287 Networking C:POJ-2031 Building a Space Station D:ZOJ-1586 QS Network E:POJ-2349 Arctic...
决策树与随机森林
02-25
本文于cnblogs,介绍了决策树的生成，Bagging策略，python实现代码等。首先，在了解树模型之前，自然想到树模型和线性模型有什么区别呢？其中最重要的是，树形模型是一个一个特征进行处理，之前线性模型是所有特征...
最小生成树MATLAB代码实现
01-08
{E}) 是一个含有 n 个顶点的连通网，则按照克鲁斯卡尔算法构造最小生成树的过程为：先构造一个只含 n 个顶点，而边集为空的子图，若将该子图中各个顶点看成是各棵树上的根结点，则它是一个含有 n 棵树的一个森林。...
最小生成树
07-30
在无向图中，如果每条边都有一个权重，最小生成树是指连接所有顶点的一组边，使得这些边的总权重尽可能小，同时确保形成的树是连通的。这个概念最初由数学家Kruskal和Prim分别独立提出，因此有Kruskal算法和Prim算法...
3dMax一键生成树桩插件
03-26
这种自动化功能对于制作大规模森林场景或者需要大量树桩模型的项目来说，无疑是巨大的福音。 其次，这款插件的易用性值得一提。它无需复杂的安装过程，用户可以直接将.mse文件拖放到3dMax的视口内启动。这种方式...
代码随想录算法训练营Day 63| 图论 part03 | 417.太平洋大西洋水流问题、827.最大人工岛、127. 单词接龙
最新发布
m0_51759998的博客
07-25 362
用两个visited来表示。
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 985
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 304
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 316
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
算法-KMP字符串匹配
xx_xb的博客
07-23 326
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
树，生成树，森林，最小生成树
03-12
树是一种非常常见的数据结构，它由节点和边组成，具有以下特点： 1. 树中有一个特殊的节点称为根节点，其他节点都通过边与根节点相连。 2. 每个节点可以有零个或多个子节点，子节点与父节点之间通过边相连。 3. 树中的任意两个节点之间只有唯一的路径。 生成树是指在一个无向图中选择一些边，使得这些边连接了图中的所有节点，并且没有形成环路。生成树可以看作是原图的一个子图，它包含了原图中的所有节点，并且是一个树结构。 森林是由多个互不相交的树组成的集合。换句话说，森林是由多个独立的树构成的，每个树都是一个独立的生成树。 最小生成树是指在一个带权无向图中选择一些边，使得这些边连接了图中的所有节点，并且总权值最小。最小生成树可以用来解决一些优化问题，例如在一个网络中选择最短路径或者最小成本的通信线路。
评论 35
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值