图——模板

package Graph

// Node 点结构的描述
type Node struct {
	Value int     // 编号
	In    int     // 入度,多少点连向我
	Out   int     // 出度
	Nexts []*Node // 直接邻居，直接邻居，由自己的边出发能到谁
	Edges []*Edge // 边集合
}

// Edge 边的描述
type Edge struct {
	Weight int   // 权重
	From   *Node // 有向边
	To     *Node
}

func NewNode(value int) *Node {
	return &Node{
		Value: value,
		In:    0,
		Out:   0,
		Nexts: make([]*Node, 0),
		Edges: make([]*Edge, 0),
	}
}

func NewEdge(weight int, from, to *Node) *Edge {
	return &Edge{
		Weight: weight,
		From:   from,
		To:     to,
	}
}

// Graph 图的描述
type Graph struct {
	Nodes map[int]*Node  //点集合  0 -- > Node{}
	Edges map[*Edge]bool //边集合
}

func (this *Graph) String1() string {
	return ""
}
func NewGraph() *Graph {
	return &Graph{
		Nodes: make(map[int]*Node, 0),
		Edges: make(map[*Edge]bool),
	}
}

// CreateGraph matrix 所有的边
// N*3的矩阵 代表 权值，起点，终点
// [weight,from节点上面的值，to节点上面的值]
func CreateGraph(matrix [][]int) *Graph {
	graph := NewGraph()
	for i := 0; i < len(matrix); i++ {
		weight := matrix[i][0]
		from := matrix[i][1]
		to := matrix[i][2]

		if _, ok := graph.Nodes[from]; !ok {
			graph.Nodes[from] = NewNode(from)
		}
		if _, ok := graph.Nodes[to]; !ok {
			graph.Nodes[to] = NewNode(to)
		}

		fromNode := graph.Nodes[from]
		toNode := graph.Nodes[to]

		newEdge := NewEdge(weight, fromNode, toNode)
		fromNode.Nexts = append(fromNode.Nexts, toNode)
		fromNode.Out++
		toNode.In++
		fromNode.Edges = append(fromNode.Edges, newEdge)
		graph.Edges[newEdge] = true // append(graph.Edges, newEdge)
	}
	return graph
}

/*
图
1.由点的集合和边的集合构成
2.虽然存在有向图和无向图的概念，但实际上都可以用有向图来表达
3.边上可能带有权值
*/

/*
                                    A
                                //    \\
                               //      \\
                            3 //4      8\\9
                             //           D
                            //     6    1//2
                            C ==========B
                                   5
邻接表法
   A: C, D
   B: C, D
   C: A, B
   D: B, A

邻接矩阵法
     A    B   C   D
  A  0   无穷  3   8
  B  无穷  0   5   2
  C  4    6   0   无穷
  D 无穷   1   无穷 0


不要在各种算法在所有结构上玩一遍
[7,0,4]      权重, from , to
[4,1,3]
[3,2,3]
[8,2,4]
                   7
              0---------->4
                          /\
                            \ 8
             1----->3<------2
                4       3

表达图的结构篇幅非常大
转换成自己的结构，调用线程的模板
*/

/*
图结构表达
1.邻接表法
2.临街矩阵法
3.除此之外还有其他众多的方式
*/
/*
图的面试题如何搞定
图的算法都不算难，只不过coding的代价比较高
1.先用自己熟悉的方式，实现图结构的表达
2.在自己熟悉的结构上，实现所有常用的图的算法作为模板
3.把面试题提供的图结构转化为自己熟悉的图结构，在调用模板或改写即可
*/

/*
图的宽度优先遍历和图的深度优先遍历
宽度优先遍历
1.利用队列实现
2.从源节点开始一次按照宽度进队列，然后弹出
3.每次弹出一个点，把该节点所有没有进过队列的邻接点放入队列
4.直到队列变空

深度优先遍历
1.利用栈实现
2.从源节点开始把节点按照深度放入栈，然后弹出
3.每弹出一个点，把该节点下一个没有进过栈的邻接点放入栈
4.直到栈变空

*/