图及相关算法
图
准备找实习了，把忘了的东西从头捡一捡
基本实现
大一时候有个特别蠢的问题，一直老想为什么不内置图的实现，现在想想真是蠢到家了……
Go语言实现无向无环图
import "fmt"
//Implment by adjacency matrix
type graphadjMat struct {
vertices []int
adjMat [][]int
}
func newGraphAdjMat(vertices []int, edges [][]int) *graphadjMat {
n := len(vertices)
adjMat := make([][]int, n)
for i := range adjMat {
adjMat[i] = make([]int, n)
}
g := &graphadjMat{
vertices: vertices,
adjMat: adjMat,
}
for i := range edges {
g.addEdge(edges[i][0], edges[i][1])
}
return g
}
func (g *graphadjMat) addVertex(val int) {
n := g.size()
g.vertices = append(g.vertices, val)
newRow := make([]int, n)
g.adjMat = append(g.adjMat, newRow)
for i := range g.adjMat {
//Looking at the matirx horizontally,the action is euqivalent to inserting 0 at the end of the row
g.adjMat[i] = append(g.adjMat[i], 0)
}
}
func (g *graphadjMat) removeVertex(index int) {
if index >= g.size() {
fmt.Errorf("%s", "Index out of Bounds")
return
}
g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)
g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)
for i := range g.adjMat {
g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)
}
}
// acyclic graph [ˌeɪˈsaɪklɪk ɡræf]
func (g *graphadjMat) addEdge(i, j int) {
if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
fmt.Errorf("%s", "Index out of bounds")
}
g.adjMat[i][j] = 1
g.adjMat[j][i] = 1
}
func (g *graphadjMat) removeEdge(i, j int) {
if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
fmt.Errorf("%s", "Index out of bounds")
}
g.adjMat[i][j] = 0
g.adjMat[j][i] = 0
}
func (g *graphadjMat) size() int {
return len(g.vertices)
}
func sum[T int | int16 | int32 | int64](nums []T) T {
var sum T
for _, v := range nums {
sum += v
}
return sum
}
func max[T int | int16 | int32 | int64](a, b T) T {
if a > b {
return a
} else {
return b
}
}
func minWithT[T int | int16 | int32 | int64](numList ...T) T {
var minValue T = numList[0]
for _, v := range numList {
if minValue > v {
minValue = v
}
}
return minValue
}
type vertex struct {
val int
}
type graphadjMat struct {
vertices []int
adjMat [][]int
}
type graphAdjList struct {
adjList map[vertex][]vertex
}
//Implement by adjacency list
func newGraphAdjList(edges [][]vertex) *graphAdjList {
g := &graphAdjList{
adjList: make(map[vertex][]vertex),
}
for _, edge := range edges {
g.addVertex(edge[0])
g.addVertex(edge[1])
g.addEdge(edge[0], edge[1])
}
return g
}
func (g *graphAdjList) size() int {
return len(g.adjList)
}
func (g *graphAdjList) addVertex(ver vertex) {
_, ok := g.adjList[ver]
if ok {
fmt.Errorf("%s", "The vertex has been found")
return
}
g.adjList[ver] = make([]vertex, 0)
}
func (g *graphAdjList) deleteVertex(ver vertex) {
_, ok := g.adjList[ver]
if !ok {
panic("error,the vertex cant be found")
}
delete(g.adjList, ver)
for i, list := range g.adjList {
g.adjList[i] = deleteSliceElems(list, ver)
}
}
func (g *graphAdjList) addEdge(ver1, ver2 vertex) {
_, ok1 := g.adjList[ver1]
_, ok2 := g.adjList[ver2]
if !ok1 || !ok2 || ver1 == ver2 {
panic("Error")
}
g.adjList[ver1] = append(g.adjList[ver1], ver2)
g.adjList[ver2] = append(g.adjList[ver2], ver1)
}
func (g *graphAdjList) removeEdge(ver1, ver2 vertex) {
_, ok1 := g.adjList[ver1]
_, ok2 := g.adjList[ver2]
if !ok1 || !ok2 || ver1 == ver2 {
panic("Error")
}
g.adjList[ver1] = deleteSliceElems(g.adjList[ver1], ver1)
g.adjList[ver2] = deleteSliceElems(g.adjList[ver2], ver2)
}
func deleteSliceElems(slice []vertex, ver vertex) []vertex {
for i, v := range slice {
if v == ver {
slice = append(slice[:i], slice[i+1:]...)
break
}
}
return slice
}
Union-Find algorithm（并查集算法）
Overview
作为最小生成树算法的前置内容，以及解决部分问题的有效解法，并查集算法有必要学习并记录下来
API we need to implement（需要实现的API）
type UF struct{
func union(p,q int)
func connected(p,q int) bool
func count() int
}
union函数表示将p与q两节点连通connected函数表示判断p与q节点是否联通count函数将返回图中的连通分量数量- 请注意，上述内容不符合Go语言语法要求，仅是说明举例用途
结合一下离散数学的内容，连通是一种等价关系。满足自反性、对称性、传递性
How to implement（实现思路）
设定每个节点有一个指针指向其父节点，如果父节点是自身的节点就是根节点。所以一开始所有节点应该都算是根节点。
type UF struct{
count int
parents []int
}
func newUF(n int) *UF{
uf:=&UF{count:n,parents:make([]int,n)}
for i:=0;i<n:i++{
//Every node's parents is itself when initilize
uf.parents[i]=i
}
return uf
}
如果A节点需要与B节点联通，只需要将A节点的根节点连接到B节点的根节点即可。
func (uf *UF) unionWithPro(p, q int) {
rootP := uf.findWithPro(p)
rootQ := uf.findWithPro(q)
if rootP == rootQ {
return
}
uf.parents[rootP] = rootQ
uf.count--
}
但这样会出现问题，在极端情况下，可能会经过连接形成一条链表。也就是说此时高度为N，二叉树不平衡，这样会导致如下问题：
如果我们需要判断两节点是否联通，需要判断二者的根节点是否为同一节点，所以就需要一个API可以找到某节点的根节点：
func (uf *UF) findWithPro(x int) int {
for uf.parents[x] != x {
x = uf.parents[x]
}
return x
}
不难分析，这个函数会从某个节点向上遍历直至树根，时间复杂度为高度O(logN)，但可惜正如上面所言，当树极度不平衡时，会退化为O(N)，当数据量极大时，会造成很大的性能损失。所以需要优化。
优化
问题的根源在于union函数只是粗暴的把一个根节点接到另外一个，并没有考虑两种里哪一种可以更好的维护平衡。如果我们每次都将高度较小的树接到高度较大的树下面，就可以避免这一问题了。遂修改代码如下：
type UF struct {
//the amount of connected components in the graph
count int
//a node's parents node
parents []int
//every root node's tree's height
size []int
}
func newUF(n int) *UF {
uf := &UF{count: n, parents: make([]int, n), size: make([]int, n)}
for i := 0; i < n; i++ {
uf.parents[i] = i
uf.size[i] = 1
}
return uf
}
func (uf *UF) union(p, q int) {
rootP := uf.find(p)
rootQ := uf.find(q)
if rootP == rootQ {
return
}
sizeP := uf.size[rootP]
sizeQ := uf.size[rootQ]
if sizeP > sizeQ {
uf.parents[rootQ] = rootP
uf.size[rootP] += sizeQ
} else {
uf.parents[rootP] = rootQ
uf.size[rootQ] += sizeP
}
uf.count--
}
为了判断树对应的高度，我们还需要修改UF数据结构的定义，加入size数组，存储每个根节点对应树的高度。
至此，时间复杂度下降为O(logN)。
路径压缩
此时按照上面的代码，我们也许可以得到一颗这样的树。但其实我们还可以进一步优化，因为我们实际上只关心某两个节点的根节点是不是同一个，以便来判断连通与否。所以我们可以尝试压缩路径到同一层，这样就可以将时间复杂度降为O(1)
可以通过修改find函数的逻辑实现这一操作，有迭代法和递归法两种，此处只记录效果更好的递归法：
func (uf *UF) find(x int) int {
if uf.parents[x] != x {
//we move the current node to previous layer if it doesn't fit the condition
uf.parents[x] = uf.find(uf.parents[x])
}
return uf.parents[x]
}
如果采用迭代写法，会压缩成如下的效果
如果采用递归写法，会压缩成如下：
借助路径压缩，size数组就可以去掉，保留与否均可。
Kruskal
Overview
克鲁斯卡尔是一种贪心算法，用来求图中的最小生成树。每次都选择最小的边加入（前提是保证不会形成回路），以便得到全局权重和最小。所以我们需要以下手段：
- 能够选择权值最小的边（排序解决）
- 能够判断加入后是否形成回路（并查集解决）
实现
1584. 连接所有点的最小费用 - 力扣（LeetCode）
以上题为例，将并查集也用上。
首先解决第一点，将图中权值排序，遍历每个点，计算到其他点的距离，即为此边的权值。最后排序即可。
第二点，是否形成回路，每次我们都从排序好了的边集合中选取，选取前判断此边的两点是否连通，如果已连通就跳过，未连通便加入，并在并查集中连接两点。
有一个结论是，最终形成的最小生成树一定有n(节点数量)-1条边，当我们判断已经加入这么多条边时，就可以返回最后的结果
type UF struct {
count int
parents []int
size []int
}
func newUF(n int) *UF {
uf := &UF{count: n, parents: make([]int, n), size: make([]int, n)}
for i := 0; i < n; i++ {
uf.parents[i] = i
uf.size[i] = 1
}
return uf
}
func (uf *UF) counts() int {
return uf.count
}
func (uf *UF) find(x int) int {
if uf.parents[x] != x {
uf.parents[x] = uf.find(uf.parents[x])
}
return uf.parents[x]
}
func (uf *UF) union(p, q int) {
rootP := uf.find(p)
rootQ := uf.find(q)
if rootP == rootQ {
return
}
if uf.size[rootP] > uf.size[rootQ] {
uf.parents[rootQ] = rootP
uf.size[rootP] += uf.size[rootQ]
} else {
uf.parents[rootP] = rootQ
uf.size[rootQ] += uf.size[rootP]
}
uf.count--
}
func (uf *UF) connected(p, q int) bool {
rootP := uf.find(p)
rootQ := uf.find(q)
return rootP == rootQ
}
func minCostConnectPoints(points [][]int) int {
var ans = 0
type edge struct{ v, w, dis int }
edges := []edge{}
for i := 0; i < len(points); i++ {
for j := i + 1; j < len(points); j++ {
edges = append(edges, edge{i, j, int(cal_distance(points[i][0], points[i][1],
points[j][0], points[j][1]))})
}
}
sort.Slice(edges, func(i, j int) bool { return edges[i].dis < edges[j].dis })
graphUnion := newUF(len(points))
edgeCount := len(points) - 1
for _, v := range edges {
if graphUnion.connected(v.v, v.w) {
continue
} else {
ans += v.dis
edgeCount--
if edgeCount == 0 {
break
}
graphUnion.union(v.v, v.w)
}
}
return ans
}
func cal_distance(x1, y1, x2, y2 int) float64 {
x := math.Abs(float64(x1 - x2))
y := math.Abs(float64(y1 - y2))
return x + y
}
Dijkstra
Overview
Dijkstra算法可以求解有向加权图中的单源最值路径，如何判断可以求解的最值为最大值还是最小值，需要通过以下方式：
- 首先看需求，不满足需求都是白搭（First priority）
- 如果图中每次添加边时，你的总权重都会减小，那么就可以求解最大值，反之，可以求解最小值
Dijkstra算法写起来和BFS大同小异，只是要在其中加入选择当前可到达节点中花费最小的操作
铺垫
闲的没事，换Python写一写
本文选择用邻接表形式实现图
首先我们在求解单源最短路径时，既然是路径，那就需要知道当前节点都能去到哪些节点，也就是获得某一节点的邻接节点（adjacency node）这就是第一个API
def ajd(s:int) -> List[int]:
另外我们还需要选择花费最小的道路，所以还需要知道两点间的路径权值是多少，就是第二个API：
def weight(graph: List[List[int]], fromNode: int, desNode: int) -> int:
for wList in graph[fromNode]:
if wList[0] == desNode:
return wList[1]
上面的weight函数实际逻辑需要根据图的存储结构进行适当变化
在写Dijkstra前，可以通过BFS模板来辅助理解：
def bfs_model(start:TreeNode) -> None:
queue = []
visited = set()
queue.append(start)
visited.add(start)
layerCount = 0
while len(queue)!=0:
curLayer = len(queue)
for i in range(curLayer):
curNode = queue.pop(0)
print(f"{curNode}在第{layerCount}层")
for adjNode in curNode.adj():
if adjNode not in visited:
queue.append(adjNode)
visited.add(adjNode)
step+=1
其中的while循环保证每次遍历至下一层（每次queue中保存一层的内容）有关层数或是长度的操作在while循环内操作即可
for循环则是横向遍历，一层层扩散，遍历当前层的所有节点，有关每个节点的细致操作在for循环内进行即可
针对BFS算法，有时可能需要知道每个节点所在的层数，但Dijkstra算法仅需知道两点间最短路径的长度，关心的是走到目前为止的路径和，所以for循环其实可以去掉。
或者也可以存储一个自定义的数据结构，其中包含当前节点，以及节点对应的层数。在每次入队新节点的时候，肯定是当前节点的儿子辈，传入参数是当前结构中的层数加一就可以了。
class State:
def __init__(self, node: TreeNode, depth: int):
self.depth = depth
self.node = node
def levelTraverse(root: TreeNode) -> None:
if not root:
return 0
q = []
q.append(State(root, 1))
while q:
cur = q.pop(0)
cur_node = cur.node
cur_depth = cur.depth
print(f"节点 {cur_node} 在第 {cur_depth} 层")
if cur_node.left:
q.append(State(cur_node.left, cur_depth + 1))
if cur_node.right:
q.append(State(cur_node.right, cur_depth + 1))
实现
def dijkstra_slide(start: int, graph: List[List[int]]) -> List[int]:
nodeCount = len(graph)
distTo = [0]*nodeCount
for i in range(nodeCount):
# if we need max value, use -inf, otherwise the opposite
distTo[i] = float('inf')
distTo[start] = 0
pri_queue = PriorityQueue(lambda a, b: a.distance - b.distance)
pri_queue.put(State(start, 0))
# or while not pri_queue.empty() is okay
while len(pri_queue) != 0:
curNode = pri_queue.get()
curDistance = curNode.distance
curId = curNode.id
if curDistance > distTo[curId]:
continue
for adjId in adj(curId):
if distTo[adjId] > distTo[curId]+weight(graph,curNode,adjId):
distTo[adjId] = distTo[curId]+weight(graph,curNode,adjId)
pri_queue.put(State(adjId,distTo[curId]+weight(graph,curNode,adjId)))
return distTo
不再需要visited数组避免无限循环的原因是，对于整幅图，其最小路径是确定的，队列不会一直减小。另外，使用优先队列的原因是，我们需要维护一个从小到大排列的队列，方便每次选取花费最小的路径，自然而然地就想到使用优先队列实现。
上述dijkstra函数会返回列表，对应指定start节点到其他所有节点的最小距离，如果只需要某两点间的最小距离，这么做效率显然不高，需要通过特判提前结束才行。
def dijkstra_slide(start: int, end: int,graph: List[List[int]]) -> int:
nodeCount = len(graph)
distTo = [0]*nodeCount
for i in range(nodeCount):
# if we need max value, use -inf, otherwise the opposite
distTo[i] = float('inf')
distTo[start] = 0
pri_queue = PriorityQueue(lambda a, b: a.distance - b.distance)
pri_queue.put(State(start, 0))
# or while not pri_queue.empty() is okay
while len(pri_queue) != 0:
curNode = pri_queue.get()
curDistance = curNode.distance
curId = curNode.id
#focus here, other code maybe a bit wrongs, nvm
if curId==end:
return curDistance
if curDistance > distTo[curId]:
continue
for adjId in adj(curId):
if distTo[adjId] > distTo[curId]+weight(graph,curNode,adjId):
distTo[adjId] = distTo[curId]+weight(graph,curNode,adjId)
pri_queue.put(State(adjId,distTo[curId]+weight(graph,curNode,adjId)))
return distTo
题目
743. 网络延迟时间 - 力扣（LeetCode）
符合算法要求，加权有向图，没有负权重边。并且每次添加边时，总权重和都会增加，所以可以求解最小值，同时也符合需求。
from typing import List
from queue import PriorityQueue
class State:
def __init__(self, id, distFromStart) -> None:
self.id = id
self.distFromStart = distFromStart
def __lt__(self,other):
return self.distFromStart < other.distFromStart
def weight(graph:List[List[int]],fromNode: int, desNode: int) -> int:
for wList in graph[fromNode]:
if wList[0] == desNode:
return wList[1]
def adj(graph:List[List[tuple[int]]],s: int) -> List[int]:
adjList = []
for item in graph[s]:
adjList.append(item[0])
return adjList
def dijkstra(start: int, graph: List[List[tuple[int]]]) -> List[int]:
vCount = len(graph)
distTo = [float('inf')] * vCount
distTo[start] = 0
pq = PriorityQueue()
pq.put(State(start, 0))
while not pq.empty():
curState = pq.get()
curId = curState.id
curDist = curState.distFromStart
if curDist > distTo[curId]:
continue
for (nextNodeId, weight) in graph[curId]:
distToNextNode = curDist + weight
if distTo[nextNodeId] > distToNextNode:
distTo[nextNodeId] = distToNextNode
pq.put(State(nextNodeId, distToNextNode))
return distTo
class Solution:
def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
graph = [[] for _ in range(n+1)]
for edge in times:
graph[edge[0]].append((edge[1],edge[2]))
distTo = dijkstra(k,graph)
ans = 0
for dist in distTo[1:]:
if dist == float('inf'):
return -1
ans = max(ans,dist)
return ans
1514. 概率最大的路径 - 力扣（LeetCode）
这题看着不符合要求，实际上也可以做，因为我们可以换个角度看。
对于不满足的有向图，其实无向图就是有向图，只不过是双向。
此题要求求解最大值，同样也可以解决，因为当增加一条新边时，概率都是小于1的数，并且独立事件可以通过乘积计算概率，所以总的权重和会变小，这符合可以求解最大值的要求。
from typing import List
from queue import PriorityQueue
import heapq
walkPos = [[1, 0], [-1, 0], [0, 1], [0, -1]]
class State:
def __init__(self, id:int, probability:int) -> None:
self.id = id
self.probability = probability
def __lt__(self, other):
return self.probability > other.probability
def dijkstra(start: int, end:int,graph: List[List[List[float]]]) -> List[int]:
#graph's length is the amount of nodes
res = [-1] * len(graph)
res[start] = 1
pq = []
heapq.heappush(pq,State(start,1))
while pq:
cur_node = heapq.heappop(pq)
cur_pro = cur_node.probability
cur_id = cur_node.id
if cur_id == end:
return cur_pro
if cur_pro < res[cur_id]:
continue
for neighbours in graph[cur_id]:
nextId = neighbours[0]
nextPro = neighbours[1]
if nextPro*res[cur_id] > res[nextId]:
res[nextId] = nextPro*res[cur_id]
heapq.heappush(pq,State(nextId,nextPro*res[cur_id]))
return 0.0
class Solution:
def maxProbability(self, n: int, edges: List[List[int]], succProb: List[float], start_node: int, end_node: int) -> float:
graph = [[] for _ in range(n)]
for i in range(len(edges)):
fromNode = edges[i][0]
toNode = edges[i][1]
probability = succProb[i]
graph[fromNode].append([toNode,probability])
graph[toNode].append([fromNode,probability])
return dijkstra(start_node,end_node,graph)
