算法導論 第二十二章 基本的圖算法

22.1圖的表示

圖結構G(V,E)由頂點V和邊E的集合組成，主要有鄰接鏈表表示和鄰接矩陣表示，兩者的差別如下所示：

若爲節點添加屬性則可以通過改變節點自身的值，或者爲節點添加屬性或在節點中增加新的指針的方式來實現。權重也是屬性的一種。

22.2 廣度優先搜索

對於給定一個圖中的原點，從原點出發按照到原點的距離來遍歷所有的連通節點稱爲廣度優先搜索。連接鏈表的算法廣度優先搜索算法如下：

def ENQUEUE(Q, s):
    Q.append(s)

def DEQUEUE(Q):
    r = Q.pop(0)
    return r

WHITE, GRAY, BLACK = (0, 1, 2)

class Vertex:
    def __init__(self, u):
        self.value = u
        self.color = WHITE
        self.d = float("inf")
        self.pi = None

class Edge:
    def __init__(self, u, v):
        self.fromV = u
        self.toV = v

class EdgeList:
    def __init__(self, v):
        self.vertex = v
        self.connectedV = []

class Graph:
    def __init__(self):
        self.vertexs = {}

def CONNECT(u, v):
    return Edge(u, v)

def INITGRAPH(G, edges):
    for e in edges:
        if not e.fromV.value in G.vertexs:
            G.vertexs[e.fromV.value] = EdgeList(e.fromV)
        if not e.toV.value in G.vertexs:
            G.vertexs[e.toV.value] = EdgeList(e.toV)

        G.vertexs[e.fromV.value].connectedV.append(e.toV)
        G.vertexs[e.toV.value].connectedV.append(e.fromV)

def PRINTLIST(el):
    print(el.vertex.value, ":")
    for v in el.connectedV:
        print(v.value)

def PRINTGRAPH(G):
    for v in G.vertexs:
        PRINTLIST(G.vertexs[v])
        print("-----")

def BFS(G, s):
    for v in G.vertexs:
        if v != s.value:
            G.vertexs[v].vertex.color = WHITE
            G.vertexs[v].vertex.d = float("inf")
            G.vertexs[v].vertex.pi = None

    s.color = GRAY
    s.d = 0
    s.pi = None

    Q = []
    ENQUEUE(Q, s)
    while len(Q) != 0:
        u = DEQUEUE(Q)
        for v in G.vertexs[u.value].connectedV:
            if v.color == WHITE:
                v.color = GRAY
                v.d = u.d + 1
                v.pi = u
                ENQUEUE(Q, v)
        u.color = BLACK
        print(u.value, u.d)

def PRINT_PATH(G, s, v):
    if v == s:
        print(s.value)
    elif v.pi == None:
        print("no path from ", s.value, " to ", v.value, "exists")
    else:
        PRINT_PATH(G, s, v.pi)
        print(v.value)


if __name__ == "__main__":
    r = Vertex('r')
    s = Vertex('s')
    t = Vertex('t')
    u = Vertex('u')
    v = Vertex('v')
    w = Vertex('w')
    x = Vertex('x')
    y = Vertex('y')

    edges = []
    edges.append(CONNECT(r, s))
    edges.append(CONNECT(r, v))
    edges.append(CONNECT(s, w))
    edges.append(CONNECT(w, t))
    edges.append(CONNECT(w, x))
    edges.append(CONNECT(t, x))
    edges.append(CONNECT(t, u))
    edges.append(CONNECT(x, u))
    edges.append(CONNECT(x, y))
    edges.append(CONNECT(u, y))

    G = Graph()
    INITGRAPH(G, edges)
    PRINTGRAPH(G)

    print("**************")
    BFS(G, s)
    print("++++++++++++++")
    PRINT_PATH(G, s, y)
    

我們採用循環不變式：queue中保存的節點到原點的距離爲最短距離。採用書上的證明其正確性，概括如下：因爲廣度遍歷的先將d小的加入queue中，當節點第一次被發現時其pi的距離+1即爲最短距離。

22.3 深度優先搜索

類似與廣度優先搜索，深度優先搜索算法沿着連接的邊一路查找直到所有的連接點都已經發現在原路返回查找所有節點，實現如下：

def ENQUEUE(Q, s):
    Q.append(s)

def DEQUEUE(Q):
    r = Q.pop(0)
    return r

WHITE, GRAY, BLACK = (0, 1, 2)

class Vertex:
    def __init__(self, u):
        self.value = u
        self.color = WHITE
        self.d = float("inf")
        self.f = float("inf")
        self.pi = None

class Edge:
    def __init__(self, u, v):
        self.fromV = u
        self.toV = v

class EdgeList:
    def __init__(self, v):
        self.vertex = v
        self.connectedV = []

class Graph:
    def __init__(self):
        self.vertexs = {}

def CONNECT(u, v):
    return Edge(u, v)

def INITGRAPH(G, edges):
    for e in edges:
        if not e.fromV.value in G.vertexs:
            G.vertexs[e.fromV.value] = EdgeList(e.fromV)
        if not e.toV.value in G.vertexs:
            G.vertexs[e.toV.value] = EdgeList(e.toV)

        G.vertexs[e.fromV.value].connectedV.append(e.toV)
        #G.vertexs[e.toV.value].connectedV.append(e.fromV)

def PRINTLIST(el):
    print(el.vertex.value, ":")
    for v in el.connectedV:
        print(v.value)

def PRINTGRAPH(G):
    for v in G.vertexs:
        PRINTLIST(G.vertexs[v])
        print("-----")

global time
time = 0
def DFS(G):
    for u in sorted(G.vertexs.keys()):
        G.vertexs[u].vertex.color = WHITE
        G.vertexs[u].vertex.pi = None
    global time
    time = 0
    for u in sorted(G.vertexs.keys()):
        if G.vertexs[u].vertex.color == WHITE:
            DFS_VISIT(G, G.vertexs[u].vertex)

def DFS_VISIT(G, u):
    global time
    time = time + 1
    u.d = time
    u.color = GRAY
    for v in G.vertexs[u.value].connectedV:
        if v.color == WHITE:
            v.pi = u
            DFS_VISIT(G, v)
    u.color = BLACK
    time = time + 1
    u.f = time
    print(u.value, u.d, u.f)

if __name__ == "__main__":
    u = Vertex('u')
    v = Vertex('v')
    w = Vertex('w')
    x = Vertex('x')
    y = Vertex('y')
    z = Vertex('z')

    edges = []
    edges.append(CONNECT(u, v))
    edges.append(CONNECT(u, x))
    edges.append(CONNECT(v, y))
    edges.append(CONNECT(w, y))
    edges.append(CONNECT(w, z))
    edges.append(CONNECT(x, v))
    edges.append(CONNECT(y, x))
    edges.append(CONNECT(z, z))

    G = Graph()
    INITGRAPH(G, edges)
    PRINTGRAPH(G)

    print("===========")
    DFS(G)

根據檢索的邊的連接點的不同，可以將邊分爲如下類型：

而且易證深度優先搜索有如下性質：

22.4 拓撲排序

拓撲排序就是無向環圖的深度優先遍歷中u.f值的由大到小的線性排序。

def ENQUEUE(Q, s):
    Q.append(s)

def DEQUEUE(Q):
    r = Q.pop(0)
    return r

WHITE, GRAY, BLACK = (0, 1, 2)

class Vertex:
    def __init__(self, u):
        self.value = u
        self.color = WHITE
        self.d = float("inf")
        self.f = float("inf")
        self.pi = None

class Edge:
    def __init__(self, u, v):
        self.fromV = u
        self.toV = v

class EdgeList:
    def __init__(self, v):
        self.vertex = v
        self.connectedV = []

class Graph:
    def __init__(self):
        self.vertexs = {}

def CONNECT(u, v):
    return Edge(u, v)

def INITGRAPH(G, edges):
    for e in edges:
        if not e.fromV.value in G.vertexs:
            G.vertexs[e.fromV.value] = EdgeList(e.fromV)
        if not e.toV.value in G.vertexs:
            G.vertexs[e.toV.value] = EdgeList(e.toV)

        G.vertexs[e.fromV.value].connectedV.append(e.toV)
        #G.vertexs[e.toV.value].connectedV.append(e.fromV)

def PRINTLIST(el):
    print(el.vertex.value, ":")
    for v in el.connectedV:
        print(v.value)

def PRINTGRAPH(G):
    for v in G.vertexs:
        PRINTLIST(G.vertexs[v])
        print("-----")

global time
time = 0
def DFS(G, TG):
    for u in sorted(G.vertexs.keys()):
        G.vertexs[u].vertex.color = WHITE
        G.vertexs[u].vertex.pi = None
    global time
    time = 0
    for u in sorted(G.vertexs.keys()):
        if G.vertexs[u].vertex.color == WHITE:
            DFS_VISIT(G, G.vertexs[u].vertex, TG)

def DFS_VISIT(G, u, TG):
    global time
    time = time + 1
    u.d = time
    u.color = GRAY
    for v in G.vertexs[u.value].connectedV:
        if v.color == WHITE:
            v.pi = u
            DFS_VISIT(G, v, TG)
    u.color = BLACK
    time = time + 1
    u.f = time
    TG.append(u)
    #print(u.value, u.d, u.f)

def TOPOLOGICAL_SORT(G):
    TG = []
    DFS(G, TG)
    return TG

if __name__ == "__main__":
    a = Vertex('a')
    b = Vertex('b')
    c = Vertex('c')
    d = Vertex('d')
    e = Vertex('e')
    f = Vertex('f')
    g = Vertex('g')
    h = Vertex('h')
    i = Vertex('i')

    edges = []
    edges.append(CONNECT(a, b))
    edges.append(CONNECT(a, d))
    edges.append(CONNECT(b, c))
    edges.append(CONNECT(d, c))
    edges.append(CONNECT(e, e))
    edges.append(CONNECT(f, g))
    edges.append(CONNECT(f, i))
    edges.append(CONNECT(g, i))
    edges.append(CONNECT(g, d))
    edges.append(CONNECT(h, i))



    G = Graph()
    INITGRAPH(G, edges)
    PRINTGRAPH(G)

    print("===========")
    TG = TOPOLOGICAL_SORT(G)
    for u in TG:
        print(u.value, u.d, u.f)

22.5 強連通分量
強連通分量其實就是環，把圖G中的環歸併到一起，就能將有環圖變爲無環圖，無環圖的許多算法可以被應用。如下圖：

通過如下代碼實現：

def ENQUEUE(Q, s):
    Q.append(s)

def DEQUEUE(Q):
    r = Q.pop(0)
    return r

WHITE, GRAY, BLACK = (0, 1, 2)

class Vertex:
    def __init__(self, u):
        self.value = u
        self.color = WHITE
        self.d = float("inf")
        self.f = float("inf")
        self.pi = None
        self.k = 0

class Edge:
    def __init__(self, u, v):
        self.fromV = u
        self.toV = v

class EdgeList:
    def __init__(self, v):
        self.vertex = v
        self.connectedV = []

class Graph:
    def __init__(self):
        self.vertexs = {}

def CONNECT(u, v):
    return Edge(u, v)

def INITGRAPH(G, edges):
    for e in edges:
        if not e.fromV.value in G.vertexs:
            G.vertexs[e.fromV.value] = EdgeList(e.fromV)
        if not e.toV.value in G.vertexs:
            G.vertexs[e.toV.value] = EdgeList(e.toV)

        G.vertexs[e.fromV.value].connectedV.append(e.toV)
        #G.vertexs[e.toV.value].connectedV.append(e.fromV)

def PRINTLIST(el):
    print(el.vertex.value, ":")
    for v in el.connectedV:
        print(v.value)

def PRINTGRAPH(G):
    for v in G.vertexs:
        PRINTLIST(G.vertexs[v])
        print("-----")

global time
time = 0
def DFS(G, TG, keys):
    for u in keys:
        G.vertexs[u].vertex.color = WHITE
        G.vertexs[u].vertex.pi = None
    global time
    time = 0
    k = 1
    for u in sorted(G.vertexs.keys()):
        if G.vertexs[u].vertex.color == WHITE:
            DFS_VISIT(G, G.vertexs[u].vertex, TG, k)
            k = k + 1

def DFS_VISIT(G, u, TG, k):
    global time
    time = time + 1
    u.d = time
    u.color = GRAY
    for v in G.vertexs[u.value].connectedV:
        if v.color == WHITE:
            v.pi = u
            DFS_VISIT(G, v, TG, k)
    u.color = BLACK
    time = time + 1
    u.f = time
    u.k = k
    TG.append(u)
    #print(u.value, u.d, u.f)

def TOPOLOGICAL_SORT(G, keys):
    TSG = []
    DFS(G, TSG, keys)
    return TSG

def TRANSPOSE(G):
    edges = []
    for k in G.vertexs.keys():
        u = G.vertexs[k].vertex
        for v in G.vertexs[u.value].connectedV:
            edges.append(CONNECT(v, u))

    GT = Graph()
    INITGRAPH(GT, edges)
    return GT

def STRONGLY_CONNECTED_COMPONENTS(G, k):
    GT = TRANSPOSE(G)

    tsg = TOPOLOGICAL_SORT(G, k)
    keys = []
    for u in tsg:
        keys.insert(0,u.value)
        print(u.value)

    gtts = []
    DFS(GT, gtts, keys)
    print("------------")
    k = 0
    for u in gtts:
        if u.k != k:
            print("|")
            k = u.k
        print(u.value)

if __name__ == "__main__":
    a = Vertex('a')
    b = Vertex('b')
    c = Vertex('c')
    d = Vertex('d')
    e = Vertex('e')
    f = Vertex('f')
    g = Vertex('g')
    h = Vertex('h')

    edges = []
    edges.append(CONNECT(a, b))
    edges.append(CONNECT(b, c))
    edges.append(CONNECT(b, e))
    edges.append(CONNECT(b, f))
    edges.append(CONNECT(c, d))
    edges.append(CONNECT(c, g))
    edges.append(CONNECT(d, c))
    edges.append(CONNECT(d, h))
    
    edges.append(CONNECT(e, a))
    edges.append(CONNECT(e, f))
    edges.append(CONNECT(f, g))
    edges.append(CONNECT(g, f))
    edges.append(CONNECT(g, h))
    edges.append(CONNECT(h, h))



    G = Graph()
    INITGRAPH(G, edges)
    PRINTGRAPH(G)

    #STRONGLY_CONNECTED_COMPONENTS(G, ['c', 'g','f','h','d','b','e','a'])
    keys = sorted(G.vertexs.keys())
    print(keys)
    STRONGLY_CONNECTED_COMPONENTS(G, keys)

習題解答