Thuật toán tốt nhất để phát hiện các chu kỳ trong đồ thị có hướng

Thuật toán hiệu quả nhất để phát hiện tất cả các chu kỳ trong đồ thị có hướng là gì?

Tôi có một biểu đồ được định hướng đại diện cho một lịch trình các công việc cần được thực hiện, một công việc là một nút và một phụ thuộc là một cạnh. Tôi cần phát hiện trường hợp lỗi của một chu kỳ trong biểu đồ này dẫn đến sự phụ thuộc theo chu kỳ.

Thuật toán các thành phần được kết nối mạnh mẽ của Tarjan có O(|E| + |V|)độ phức tạp về thời gian.

Đối với các thuật toán khác, xem các thành phần được kết nối mạnh mẽ trên Wikipedia.

Cho rằng đây là một lịch trình công việc, tôi nghi ngờ rằng đến một lúc nào đó bạn sẽ sắp xếp chúng vào một trật tự thực hiện được đề xuất.

Nếu đó là trường hợp, thì việc thực hiện sắp xếp theo cấu trúc liên kết trong mọi trường hợp có thể phát hiện chu kỳ. UNIX tsortchắc chắn làm được. Tôi nghĩ rằng có khả năng là hiệu quả hơn để phát hiện các chu kỳ cùng lúc với tsorting, hơn là trong một bước riêng biệt.

Vì vậy, câu hỏi có thể trở thành, "làm thế nào để tôi tsort hiệu quả nhất", thay vì "làm thế nào để tôi phát hiện các vòng lặp hiệu quả nhất". Câu trả lời có lẽ là "sử dụng thư viện", nhưng không thành công trong bài viết Wikipedia sau:

http://en.wikipedia.org/wiki/Topological_sorting

có mã giả cho một thuật toán và mô tả ngắn gọn về một thuật toán khác từ Tarjan. Cả hai đều có O(|V| + |E|)thời gian phức tạp.

Cách đơn giản nhất để làm điều đó là thực hiện một chiều sâu trước tiên (DFT) của biểu đồ .

Nếu đồ thị có ncác đỉnh, đây là O(n)thuật toán phức tạp thời gian. Vì bạn có thể sẽ phải thực hiện một DFT bắt đầu từ mỗi đỉnh, nên tổng độ phức tạp trở thành O(n^2).

Bạn phải duy trì một ngăn xếp chứa tất cả các đỉnh trong chiều ngang hiện tại đầu tiên , với phần tử đầu tiên của nó là nút gốc. Nếu bạn gặp một phần tử đã có trong ngăn xếp trong DFT, thì bạn có một chu kỳ.

Theo Bổ đề 22.11 của Cormen và cộng sự, Giới thiệu về Thuật toán (CLRS):

Đồ thị có hướng G là theo chu kỳ khi và chỉ khi tìm kiếm theo chiều sâu của G không có cạnh sau.

Điều này đã được đề cập trong một số câu trả lời; ở đây tôi cũng sẽ cung cấp một ví dụ mã dựa trên chương 22 của CLRS. Biểu đồ ví dụ được minh họa dưới đây.

Mã giả của CLRS cho tìm kiếm theo chiều sâu đọc:

Trong ví dụ trong CLRS Hình 22.4, biểu đồ bao gồm hai cây DFS: một bao gồm các nút u , v , x và y và một nút khác của các nút w và z . Mỗi cây chứa một cạnh sau: một từ x đến v và một cây khác từ z đến z (một vòng lặp tự).

Nhận thức chính là một cạnh sau gặp phải khi, trong DFS-VISIThàm, trong khi lặp qua các hàng xóm vcủa u, một nút được bắt gặp với GRAYmàu.

Mã Python sau đây là sự điều chỉnh mã giả của CLRS với một ifmệnh đề được thêm vào để phát hiện các chu kỳ:

import collections


class Graph(object):
    def __init__(self, edges):
        self.edges = edges
        self.adj = Graph._build_adjacency_list(edges)

    @staticmethod
    def _build_adjacency_list(edges):
        adj = collections.defaultdict(list)
        for edge in edges:
            adj[edge[0]].append(edge[1])
        return adj


def dfs(G):
    discovered = set()
    finished = set()

    for u in G.adj:
        if u not in discovered and u not in finished:
            discovered, finished = dfs_visit(G, u, discovered, finished)


def dfs_visit(G, u, discovered, finished):
    discovered.add(u)

    for v in G.adj[u]:
        # Detect cycles
        if v in discovered:
            print(f"Cycle detected: found a back edge from {u} to {v}.")

        # Recurse into DFS tree
        if v not in finished:
            dfs_visit(G, v, discovered, finished)

    discovered.remove(u)
    finished.add(u)

    return discovered, finished


if __name__ == "__main__":
    G = Graph([
        ('u', 'v'),
        ('u', 'x'),
        ('v', 'y'),
        ('w', 'y'),
        ('w', 'z'),
        ('x', 'v'),
        ('y', 'x'),
        ('z', 'z')])

    dfs(G)

Lưu ý rằng trong ví dụ này, timemã giả trong CLRS không bị bắt vì chúng tôi chỉ quan tâm đến việc phát hiện các chu kỳ. Ngoài ra còn có một số mã soạn sẵn để xây dựng biểu diễn danh sách kề của biểu đồ từ danh sách các cạnh.

Khi đoạn script này được thực thi, nó sẽ in ra kết quả sau:

Cycle detected: found a back edge from x to v.
Cycle detected: found a back edge from z to z.

Đây chính xác là các cạnh sau trong ví dụ trong CLRS Hình 22.4.

Bắt đầu với DFS: một chu kỳ tồn tại khi và chỉ khi một cạnh sau được phát hiện trong DFS . Điều này được chứng minh là kết quả của lý thuyết đường trắng.

Theo tôi, thuật toán dễ hiểu nhất để phát hiện chu kỳ trong đồ thị có hướng là thuật toán tô màu đồ thị.

Về cơ bản, thuật toán tô màu biểu đồ đi theo biểu đồ theo cách DFS (Depth First Search, có nghĩa là nó khám phá một đường dẫn hoàn toàn trước khi khám phá một đường dẫn khác). Khi tìm thấy cạnh sau, nó đánh dấu biểu đồ là chứa một vòng lặp.

Để được giải thích sâu hơn về thuật toán tô màu đồ thị, vui lòng đọc bài viết này: http : //www.geekforgeek.org/detect- Motorcycle-direct-graph-USE-colors/

Ngoài ra, tôi cung cấp triển khai tô màu đồ thị trong JavaScript https://github.com/dexcodeinc/graph_alerskym.js/blob/master/graph_alerskym.js

Nếu bạn không thể thêm thuộc tính "đã truy cập" vào các nút, hãy sử dụng một tập hợp (hoặc bản đồ) và chỉ cần thêm tất cả các nút đã truy cập vào tập hợp trừ khi chúng đã có trong tập hợp. Sử dụng một khóa duy nhất hoặc địa chỉ của các đối tượng làm "khóa".

Điều này cũng cung cấp cho bạn thông tin về nút "gốc" của phụ thuộc theo chu kỳ sẽ có ích khi người dùng phải khắc phục sự cố.

Một giải pháp khác là cố gắng tìm sự phụ thuộc tiếp theo để thực thi. Đối với điều này, bạn phải có một số ngăn xếp nơi bạn có thể nhớ bạn đang ở đâu và bạn cần làm gì tiếp theo. Kiểm tra xem một phụ thuộc đã có trên ngăn xếp này trước khi bạn thực hiện nó. Nếu có, bạn đã tìm thấy một chu kỳ.

Mặc dù điều này dường như có độ phức tạp của O (N * M), bạn phải nhớ rằng ngăn xếp có độ sâu rất hạn chế (vì vậy N nhỏ) và M trở nên nhỏ hơn với mỗi phụ thuộc mà bạn có thể kiểm tra là "thực thi" cộng bạn có thể dừng tìm kiếm khi bạn tìm thấy một chiếc lá (vì vậy bạn không bao giờ phải kiểm tra mọi nút -> M cũng sẽ nhỏ).

Trong MetaMake, tôi đã tạo biểu đồ dưới dạng danh sách các danh sách và sau đó xóa mọi nút khi tôi thực hiện chúng để cắt giảm khối lượng tìm kiếm một cách tự nhiên. Tôi chưa bao giờ thực sự phải chạy một kiểm tra độc lập, tất cả diễn ra tự động trong quá trình thực thi bình thường.

Nếu bạn cần chế độ "chỉ kiểm tra", chỉ cần thêm cờ "chạy khô" sẽ vô hiệu hóa việc thực hiện các công việc thực tế.

Không có thuật toán nào có thể tìm thấy tất cả các chu kỳ trong đồ thị có hướng trong thời gian đa thức. Giả sử, đồ thị có hướng có n nút và mỗi cặp nút có kết nối với nhau có nghĩa là bạn có một đồ thị hoàn chỉnh. Vì vậy, bất kỳ tập hợp con không trống nào của n nút này chỉ ra một chu kỳ và có 2 ^ n-1 số tập con như vậy. Vì vậy, không có thuật toán thời gian đa thức tồn tại. Vì vậy, giả sử bạn có một thuật toán hiệu quả (không ngu ngốc) có thể cho bạn biết số chu kỳ được định hướng trong biểu đồ, trước tiên bạn có thể tìm thấy các thành phần được kết nối mạnh, sau đó áp dụng thuật toán của bạn trên các thành phần được kết nối này. Vì chu kỳ chỉ tồn tại trong các thành phần chứ không phải giữa chúng.

Tôi đã thực hiện vấn đề này trong sml (lập trình bắt buộc). Đây là phác thảo. Tìm tất cả các nút có mức độ không chính xác hoặc bằng 0. Các nút như vậy không thể là một phần của một chu kỳ (vì vậy hãy loại bỏ chúng). Tiếp theo loại bỏ tất cả các cạnh đến hoặc đi từ các nút như vậy. Áp dụng đệ quy quy trình này vào biểu đồ kết quả. Nếu ở cuối bạn không bị bỏ lại với bất kỳ nút hoặc cạnh nào, đồ thị không có bất kỳ chu kỳ nào, thì nó có.

Cách tôi làm là thực hiện Sắp xếp tô pô, đếm số đỉnh được truy cập. Nếu số đó nhỏ hơn tổng số đỉnh trong DAG, bạn có một chu kỳ.

/mathpro/16393/finding-a- Motorcycle-of -fixed-length Motorcycle-of -fixed-length Tôi thích giải pháp này đặc biệt tốt nhất cho 4 chiều dài :)

Ngoài ra thuật sĩ vật lý nói rằng bạn phải làm O (V ^ 2). Tôi tin rằng chúng ta chỉ cần O (V) / O (V + E). Nếu đồ thị được kết nối thì DFS sẽ truy cập tất cả các nút. Nếu đồ thị đã kết nối các đồ thị phụ thì mỗi lần chúng ta chạy DFS trên một đỉnh của đồ thị phụ này, chúng ta sẽ tìm thấy các đỉnh được kết nối và sẽ không phải xem xét các đồ thị này cho lần chạy tiếp theo của DFS. Do đó, khả năng chạy cho mỗi đỉnh là không chính xác.

Nếu DFS tìm thấy một cạnh chỉ đến một đỉnh đã được truy cập, bạn có một chu kỳ ở đó.

Như bạn đã nói, bạn đã thiết lập các công việc, nó cần được thực hiện theo thứ tự nhất định. Topological sortđưa ra yêu cầu của bạn để sắp xếp công việc (hoặc cho các vấn đề phụ thuộc nếu đó là một direct acyclic graph). Chạy dfsvà duy trì một danh sách, và bắt đầu thêm nút vào đầu danh sách, và nếu bạn gặp phải một nút đã được truy cập. Sau đó, bạn tìm thấy một chu kỳ trong đồ thị đã cho.

Nếu một đồ thị thỏa mãn tính chất này

|e| > |v| - 1

sau đó đồ thị chứa ít nhất trên chu kỳ.