简介
图结构本质上还有多叉树的变种,图结构在逻辑上，由于若干个节点和边组成。但在实际落地中，一般用邻接表，邻接矩阵来存储图
在标准的树结构中，一般都是单链表表示，即只允许父节点指向子节点，两个子节点之间也不允许互相指向。
而图中，则是双链表放飞自我版，既可以父子之间互相指向，又可以子节点互相链接，形成复杂的网络结构。
图的逻辑视图
可以看到一幅图由节点(Vertex)与边(Edge)组成，那么从直觉出发，我们可以认为它的数据结构应该是这个样子的
public class Vertex { public int Value { get; set; } Vertex[] Neighbors { get; set; } } 可以看到，与多叉树并无区别，所以图在本质上还是树.因此适用于树的DFS/BFS算法同样适用于图
Degree
图论中有一个独特的概念，叫度(Degree).
在没有方向的图中，Degree就是每个节点相连边的条数。在有方向的图中，Degree被细分为indegree和outdegree
比如在此图中，节点3的indegree为3，outdegree为1。节点4的indegree为3，outdegree为0
图的实际视图
与上面代码相反的是，图的实际存储方式如下
邻接表
0号节点存储着它的indegree，【4，3，1】
2号节点存储着它的indegree，【3，2，4】
......
代码结构如下:
//邻接表 //List存节点，Int[]存储相邻节点 List<int[]> grath = new List<int[]>(); 邻接矩阵
邻接矩阵则是把所有可能的节点都穷举描绘出来，然后再到上面标点。
代码结构如下：
//邻接矩阵 //二维数组 bool[,] matrix = new bool[5,5]; 为什么会有两种不同存储方式？
因为任何结构都有两个考虑因素，时间与空间。这是一个万能公式。
- 可以直观的看到，邻接矩阵是空间换时间，通过填充整个矩阵,只需要matrix[i,j]就能以O(1)的复杂度实现查找。
- 而邻接表则是时间换空间,只存储必要的信息，节省了空间，但查找复杂度退化为O(N)
加权图
上面介绍的图最基本的结构，是不是很简单？所有的复杂结构都是在简单上一步一步演化的，图也不例外。
那加权图又如何实现呢？回忆我们的套路.算法共一石,空间换时间独占八斗。
邻接表加权
//List<int[]> grath = new List<int[]>(); // 空间换时间，加一个字段存权重不就好了？ List<Edge[]> grath = new List<Edge[]>(); public struct Edge { public int Indegree { get; set; } public int Weight { get; set; } }
矩阵表加权
//bool[,] matrix = new bool[5,5]; //由bool二维数组切换成int二维数组 //=0 代表没有边，!=0 代表有边且与权重 int[,] matrix = new int[5,5];
无向图
上面我们介绍的，都是有向无权图与有向加权图。那什么是无向图呢？
很简单，无向图=双向图
所以你无脑数，有几条边就有几个节点，不再区分indegree,outdegree
一个简单的图
public interface IGraphSimple { /// <summary> /// 添加一条边 /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <param name="weight"></param> void AddEdge(int from, int to, int weight); /// <summary> /// 删除一条边 /// </summary> /// <param name="from"></param> /// <param name="to"></param> void RemoveEdge(int from, int to); /// <summary> /// 判断两个节点是否相等 /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <returns></returns> bool IsEdge(int from, int to); /// <summary> /// 返回一条边的权重 /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <returns></returns> int? Weight(int from, int to); List<Edge> Neighbors(int v); } public struct Edge { /// <summary> /// 相邻的节点 /// </summary> public int Indegree { get; set; } /// <summary> /// 权重 /// </summary> public int Weight { get; set; } } /// <summary> /// 邻接表实现图 /// </summary> public class AdjacencySimple : IGraphSimple { public static void Run() { var s = new AdjacencySimple(10); s.AddEdge(0, 1, 0); s.AddEdge(0, 2, 0); s.AddEdge(2, 5, 0); s.AddEdge(2, 6, 0); s.AddEdge(1, 3, 0); s.AddEdge(1, 4, 0); s.AddEdge(3, 6, 0); s.AddEdge(3, 0, 0); s.AddEdge(6, 0, 0); s.DFSTraverse(0); } private List<List<Edge>> _graph; private bool[] _visited; private LinkedList<int> _path=new LinkedList<int>(); public AdjacencySimple(int capacity) { //init _graph = new List<List<Edge>>(capacity); _visited=new bool[capacity]; for (int i = 0; i < capacity; i++) { _graph.Add(new List<Edge>()); } } public void Add(int from, int to, int weight) { //如果是无向加权表，就调用此方法 AddEdge(from, to, weight); //多维护一遍关系 AddEdge(from,to, weight); } public void AddEdge(int from, int to, int weight) { var neighbor = new Edge() { Indegree = to, Weight = weight }; _graph[from].Add(neighbor); } public bool IsEdge(int from, int to) { foreach (var edge in _graph[from]) { if (edge.Indegree.Equals(to)) { return true; } } return false; } public List<Edge> Neighbors(int from) { return _graph[from]; } public void Remove(int from, int to) { //如果是无向加权表，就调用此方法 RemoveEdge(from, to); //多维护一遍关系 RemoveEdge(to, from); } public void RemoveEdge(int from, int to) { var neighbors = _graph[from]; foreach (var edge in neighbors) { if (edge.Indegree.Equals(to)) { neighbors.Remove(edge); break; } } } public int? Weight(int from, int to) { var neighbors = _graph[from]; foreach (var edge in neighbors) { if (edge.Indegree.Equals(to)) { return edge.Weight; } } return null; } public void DFSTraverse(int startIndex) { if (startIndex < 0 || startIndex >= _graph.Count) return; if (_visited[startIndex]) return; _visited[startIndex] = true; //前序遍历 Console.WriteLine($"index={startIndex}"); if (_graph[startIndex]?.Count > 0) { foreach (var item in _graph[startIndex]) { DFSTraverse(item.Indegree); } } //后序遍历 //Console.WriteLine($"index={index}"); } } /// <summary> /// 邻接矩阵实现图 /// </summary> public class MatrixSimple : IGraphSimple { private int[,] _matrix; private bool[] _visited; public static void Run() { var s = new MatrixSimple(10); s.AddEdge(0, 1, 1); s.AddEdge(0, 2, 2); s.AddEdge(2, 5, 3); s.AddEdge(2, 6, 4); s.AddEdge(1, 3, 5); s.AddEdge(1, 4, 6); s.AddEdge(3, 6, 7); s.AddEdge(3, 0, 8); s.AddEdge(6, 0, 9); s.DFSTraverse(0); } public MatrixSimple(int capacity) { _matrix = new int[capacity, capacity]; _visited = new bool[capacity]; } public void Add(int from, int to, int weight) { //如果是无向加权表，就调用此方法 AddEdge(from, to, weight); //多维护一遍关系 AddEdge(to, from, weight); } public void AddEdge(int from, int to, int weight) { _matrix[from, to] = weight; } public bool IsEdge(int from, int to) { return _matrix[from, to] != 0; } public List<Edge> Neighbors(int from) { var result=new List<Edge>(); var columns = _matrix.GetLength(from); for (int i = 0; i < columns; i++) { if (_matrix[columns, i] > 0) { result.Add(new Edge { Indegree = i, Weight = _matrix[columns, i] }); } } return result; } public void Remove(int from, int to) { //如果是无向加权表，就调用此方法 RemoveEdge(from, to); //多维护一遍关系 RemoveEdge(to, from); } public void RemoveEdge(int from, int to) { //0代表未使用 _matrix[from, to] = 0; } public int? Weight(int from, int to) { return _matrix[from, to]; } public void DFSTraverse(int startIndex) { if (_visited[startIndex]) return; _visited[startIndex] = true; //前序遍历 Console.WriteLine($"index={startIndex}"); for (int i = 0; i < _visited.Length; i++) { //为0代表未使用 if (_matrix[startIndex, i] == 0) continue; DFSTraverse(i); } //后序遍历 //Console.WriteLine($"index={index}"); } } 
![洛谷 P11345 [KTSC 2023 R2] 基地简化 题解](http://www.itfaba.com/wp-content/themes/kemi/timthumb.php?src=http://www.itfaba.com/wp-content/themes/kemi/img/random/3.jpg&w=218&h=124&zc=1)
