图论Graph Theory是CS里面相当重要的一个领域，也是非常博大精深的一块。这里主要实现一些比较基础的算法。
图可以分为有向图和无向图，有权图和无权图。图的基本表示方法有邻接矩阵，邻接链表。两者可以互相转换，这里都用邻接链表作为图的表示。

BFS/DFS
BFS和DFS是图的遍历的基础算法，就是从某一个节点开始遍历整个图。对图的有向性和有权性并没有要求，对无向图可视为每条边都是双向的。
简而言之，BFS就是维持一个queue，每次把节点的未遍历neighbors放进这个队列，重复此过程直至队列为空。这种方式是层层递进的。DFS则是一条道先走到黑，然后再换一条路，用递归实现会简洁很多。两个方法都需要一个辅助空间visited来记录已经遍历过的节点，避免走回头路。假如需要记录路径，可以用path代替visited。
graph = {‘A’: [‘B’, ‘C’], ‘B’: [‘D’, ‘E’], ‘C’: [‘D’, ‘E’], ‘D’: [‘E’], ‘E’: [‘A’]}

# BFS DFS
def recursive_dfs(graph, start, path=[]):
    path = path + [start]
    for node in graph[start]:
        if node not in path:
            path = recursive_dfs(graph, node, path)
    return path

def iterative_dfs(graph, start):
    path = []
    # dfs uses a stack, so that it visits the last node
    # pushed to stack (explores as deep as possible first)
    stack = [start]
    while stack:
        v = stack.pop()  # pops out the last in (go deeper)
        if v not in path:
            path += [v]  # add v to path
            stack += graph[v]  # push v's neighbors to stack
    return path

def iterative_bfs(graph, start):
    path = []
    queue = [start]
    # bfs uses a queue, so that it visits the nodes pushed
    # to the queue first. So it first visits all the neighbors
    # and then the neighbors' neighbors (explores the soroundings
    # as much as possible without going deep)
    while queue:
        v = queue.pop(0)  # pops out the first in (go wider)
        if v not in path:
            path += [v]
            queue += graph[v]  # push v's neighbors to queue
     return path 

两种方法各有千秋。T:O(V+E) S:O(V)

** Dijkstra**
问题：在无向图G=(V,E)中，假设每条边E[i]的长度为W[i]，找到顶点V0到其余各点的最短路径。这个算法是典型的单源最短路径算法，要求不能出现负权值，即W[i]>=0.
算法的思想很简单。在算法进行中的某个时刻，整个图的所有顶点可以分成两块，一块是已经完成的，一块是待完成的。那么待完成的肯定有一部分是和已经完成的部分相连的，因此它们距离源点V0的路径长度也是可以获得的，从里面挑一个最小的加入已经完成的部分，并更新这个点的下一层neighbors的可能路径值。重复步骤直至所有点都完成。
事实上，因为刚开始只有W[i]的值，可以给每个点增加一个属性，即到V0的最短路径。刚开始，只有V0到自己的值是0，别的点都是正无穷。然后考虑V0的neighbors，其可能（因为可能有更短的路径）的路径值就是V0的路径值加上V0到其的W[i]，选择一个最小的，确定其路径值。然后再考虑V0和刚刚加进来的点的neighbors的可能路径值，再找一个最小的。反复直至完成。

# Dijkstra T:O(V^2) S:O(V)
def popmin(pqueue):
    # A (ascending or min) priority queue keeps element with
    # lowest priority on top. So pop function pops out the element with
    # lowest value. It can be implemented as sorted or unsorted array
    # (dictionary in this case) or as a tree (lowest priority element is
    # root of tree)
    lowest = 1000
    keylowest = None
    for key in pqueue:
        if pqueue[key] < lowest:
            lowest = pqueue[key]
            keylowest = key
    del pqueue[keylowest]
    return keylowest

def dijkstra(graph, start):
    # Using priority queue to keep track of minium distance from start
    # to a vertex.
    pqueue = {}  # vertex: distance to start
    dist = {}  # vertex: distance to start
    pred = {}  # vertex: previous (predecesor) vertex in shortest path
    # initializing dictionaries
    for v in graph:
        dist[v] = 1000
        pred[v] = -1
    dist[start] = 0
    for v in graph:
        pqueue[v] = dist[v]  # equivalent to push into queue

    while pqueue:
        u = popmin(pqueue)  # for priority queues, pop will get the element with smallest value
        for v in graph[u].keys():  # for each neighbor of u
            w = graph[u][v]  # distance u to v
            newdist = dist[u] + w
            if (newdist < dist[v]):  # is new distance shorter than one in dist?
                # found new shorter distance. save it
                pqueue[v] = newdist
                dist[v] = newdist
                pred[v] = u

     return dist, pred 

可以看到，这里对popmin的实现是用的比较原始的O（n）方法，假如用堆的话，可以将效率提高为O(ElogV)。

** Bellman-Ford**
上面提到，Dijkstra不能在含有负权边的图上使用，而Bellman-Ford算法可以。但是这个算法效率更低，为O（VE）。假如有负权回路，会报错而不会继续进行计算（负权回路的存在让最短路径变得没有意义）。
Bellman－Ford算法可以大致分为三个部分：
第一，初始化所有点。每一个点保存一个值，表示从原点到达这个点的距离，将原点的值设为0，其它的点的值设为无穷大（表示不可达）。
第二，进行循环，循环下标为从1到n－1（n等于图中点的个数）。在循环内部，遍历所有的边，进行松弛计算。
第三，遍历途中所有的边（edge（u，v）），判断是否存在这样情况：
d（v） > d (u) + w(u,v)
有则返回false，表示途中存在从源点可达的权为负的回路。
为什么要循环n-1次？因为最短路径最多n-1条边（不会包含环）。

# Bellman-Ford T:O(VE) S:O(V)
# Step 1: For each node prepare the destination and predecessor
def initialize(graph, source):
    d = {}  # Stands for destination
    p = {}  # Stands for predecessor
    for node in graph:
        d[node] = float('Inf')  # We start admiting that the rest of nodes are very very far
        p[node] = None
    d[source] = 0  # For the source we know how to reach
    return d, p


def relax(node, neighbour, graph, d, p):
    # Step 2: If the distance between the node and the neighbour is lower than the one I have now
    if d[neighbour] > d[node] + graph[node][neighbour]:
        # Record this lower distance
        d[neighbour] = d[node] + graph[node][neighbour]
        p[neighbour] = node


def bellman_ford(graph, source):
    d, p = initialize(graph, source)
    for i in range(len(graph) - 1):  # Run this until is converges
        for u in graph:
            for v in graph[u]:  # For each neighbour of u
                relax(u, v, graph, d, p)  # Lets relax it

    # Step 3: check for negative-weight cycles
    for u in graph:
        for v in graph[u]:
            assert d[v] <= d[u] + graph[u][v]

     return d, p 

Flord-Wayshall
该算法用于求图中任意两点的最短路径，复杂度O（V^3）。这个算法是基于DP的一种算法。思想也非常简单，考虑节点u到节点v的距离为d[u][v]，假设有某个节点k使得u到k然后再到v的距离比原来的小，那就替换之。

# Floyd-Warshall T:O(V^3) S:O(V)
def floydwarshall(graph):
    # Initialize dist and pred:
    # copy graph into dist, but add infinite where there is
    # no edge, and 0 in the diagonal
    dist = {}
    pred = {}
    for u in graph:
        dist[u] = {}
        pred[u] = {}
        for v in graph:
            dist[u][v] = 1000
            pred[u][v] = -1
        dist[u][u] = 0
        for neighbor in graph[u]:
            dist[u][neighbor] = graph[u][neighbor]
            pred[u][neighbor] = u

    for t in graph:
        # given dist u to v, check if path u - t - v is shorter
        for u in graph:
            for v in graph:
                newdist = dist[u][t] + dist[t][v]
                if newdist < dist[u][v]:
                    dist[u][v] = newdist
                    pred[u][v] = pred[t][v]  # route new path through t

 return dist, pred