Yönlendirilmiş bir grafikteki döngüleri tespit etmek için en iyi algoritma

Yönlendirilmiş bir grafikteki tüm döngüleri tespit etmek için en verimli algoritma nedir?

Bir iş bir düğüm ve bağımlılık bir kenar olmak yürütülmesi gereken işleri bir program temsil eden yönlendirilmiş bir grafik var. Döngüsel bağımlılıklara yol açan bu grafikte bir döngü hata durumunu tespit etmek gerekir.

Tarjan en kuvvetli bağlı bileşenler algoritması vardır O(|E| + |V|)zaman karmaşıklığı.

Diğer algoritmalar için Wikipedia'da güçlü bir şekilde bağlı bileşenler konusuna bakın .

Bunun bir iş programı olduğu göz önüne alındığında, bir noktada bunları önerilen bir yürütme sırasına göre sıralayacağınızdan şüpheleniyorum .

Bu durumda, topolojik sıralama uygulaması her durumda döngüleri algılayabilir. UNIX tsortkesinlikle öyle. Bu nedenle, döngüleri ayrı bir adımda değil, tsorting ile aynı anda tespit etmenin daha verimli olması muhtemel olduğunu düşünüyorum.

Böylece soru, "döngüleri en verimli şekilde nasıl saptarım" yerine "en verimli şekilde nasıl çökerim" haline gelebilir. Hangi cevap büyük olasılıkla "bir kütüphane kullanın", ancak aşağıdaki Wikipedia makalesinde başarısız:

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

bir algoritma için sözde kod ve Tarjan'dan diğerinin kısa bir açıklamasına sahiptir. Her ikisinin de O(|V| + |E|)zaman karmaşıklığı vardır.

Bunu yapmanın en basit yolu , grafiğin ilk derinlik geçişini (DFT) yapmaktır .

Grafiğin nköşeleri varsa, bu bir O(n)zaman karmaşıklığı algoritmasıdır. Her tepe noktasından başlayarak muhtemelen bir DFT yapmanız gerekeceğinden, toplam karmaşıklık olur O(n^2).

İlk derinliği kök düğümü olacak şekilde, geçerli derinlikteki ilk geçişteki tüm köşeleri içeren bir yığın bulundurmalısınız . DFT sırasında zaten yığının içinde olan bir öğeyle karşılaşırsanız, bir döngünüz olur.

Cormen ve arkadaşlarının Lemma 22.11'e göre , Algoritmalara Giriş (CLRS):

Yönlendirilmiş bir G grafiği, yalnızca G'nin ilk derinlik araştırması arka kenar vermezse döngüsel değildir.

Bu birkaç cevapta belirtilmiştir; burada CLRS'in 22. bölümüne dayanan bir kod örneği de sunacağım. Örnek grafik aşağıda gösterilmiştir.

Önce derinlik araması için CLRS sahte kodunu okur:

CLRS Şekil 22.4'teki örnekte, grafik iki DFS ağacından oluşur: biri u , v , x ve y düğümlerinden ve diğeri w ve z düğümlerinden oluşur . Her ağaç bir arka kenarı içerir: gelen bir x için v ve diğer bir z için z (kendi kendine döngü).

Anahtar gerçekleştirilmesi zaman bir arka kenarı olarak karşılaşılan olmasıdır DFS-VISITkomşuları yineleme sırasında, fonksiyon varasında u, bir düğüm ile karşılaşıldığındaGRAY renk.

Aşağıdaki Python kodu, CLRS'in sözde kodunun ifdöngüleri algılayan bir cümle ile uyarlanmasıdır :

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)

Bu örnekte, time yalnızca döngüleri tespit etmekle ilgilendiğimiz için CLRS'deki sözde kodunun yakalanmadığını unutmayın. Ayrıca, kenar listesinden bir grafiğin bitişik liste temsilini oluşturmak için bazı kazan plakası kodu da vardır.

Bu komut dosyası yürütüldüğünde, aşağıdaki çıktıyı yazdırır:

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

Bunlar CLRS Şekil 22.4'teki örnekteki tam arka kenarlardır.

Bir DFS ile başlayın: yalnızca DFS sırasında bir arka kenar bulunursa bir döngü oluşur . Bu, beyaz yol teorumunun bir sonucu olarak kanıtlanmıştır.

Bence, yönlendirilmiş bir grafikte döngüyü tespit etmek için en anlaşılır algoritma, grafik boyama algoritmasıdır.

Temel olarak, grafik renklendirme algoritması grafiği DFS biçiminde yürür (Derinlik İlk Arama, başka bir yol keşfetmeden önce bir yolu tamamen araştırdığı anlamına gelir). Bir arka kenar bulduğunda grafiği bir döngü içerdiğini işaretler.

Grafik renklendirme algoritmasının derinlemesine açıklaması için lütfen şu makaleyi okuyun: http://www.geeksforgeeks.org/detect-cycle-direct-graph-using-colors/

Ayrıca, JavaScript'te grafik renklendirme uygulaması sağlıyorum https://github.com/dexcodeinc/graph_algorithm.js/blob/master/graph_algorithm.js

Düğümlere "ziyaret edilen" bir özellik ekleyemiyorsanız, bir küme (veya harita) kullanın ve zaten kümede bulunmadıkları sürece ziyaret edilen tüm düğümleri kümeye ekleyin. Benzersiz bir anahtar veya nesnelerin adresini "anahtar" olarak kullanın.

Bu ayrıca, bir kullanıcının sorunu düzeltmesi gerektiğinde kullanışlı olacak döngüsel bağımlılığın "kök" düğümü hakkında bilgi verir.

Başka bir çözüm, yürütülecek bir sonraki bağımlılığı bulmaya çalışmaktır. Bunun için, şu anda nerede olduğunuzu ve daha sonra ne yapmanız gerektiğini hatırlayabileceğiniz bir yığınınız olmalıdır. Yürütmeden önce bu yığın üzerinde bir bağımlılığın olup olmadığını kontrol edin. Eğer öyleyse, bir döngü buldunuz.

Bu, O (N * M) karmaşıklığına sahip gibi görünse de, yığının çok sınırlı bir derinliğe sahip olduğunu (bu nedenle N küçüktür) ve "yürütülen" artı olarak kontrol edebileceğiniz her bağımlılıkla M'nin küçüldüğünü hatırlamanız gerekir. (böylece bir yaprak bulduğunda aramayı durdurabilir asla - çok> M küçük olacaktır, her düğüm kontrol etmek gerekir).

MetaMake'de grafiği bir liste listesi olarak oluşturdum ve daha sonra doğal olarak arama hacmini azaltan her düğümü sildim. Asla bağımsız bir kontrol yapmak zorunda kalmadım, hepsi normal uygulama sırasında otomatik olarak gerçekleşti.

"Sadece test" moduna ihtiyacınız varsa, gerçek işlerin yürütülmesini devre dışı bırakan bir "kuru çalışma" bayrağı eklemeniz yeterlidir.

Polinom zamanında yönlendirilmiş bir grafikteki tüm döngüleri bulabilen bir algoritma yoktur. Yönlendirilen grafiğin düğümleri olduğunu ve her düğüm çiftinin birbiriyle bağlantıları olduğunu, yani tam bir grafiğiniz olduğunu varsayalım. Dolayısıyla, bu düğümlerin boş olmayan alt kümeleri bir döngüyü gösterir ve bu tür alt kümelerin 2 ^ n-1 sayısı vardır. Dolayısıyla, polinom zaman algoritması yoktur. Bu nedenle, bir grafikteki yönlendirilmiş döngü sayısını söyleyebilen verimli (aptal olmayan) bir algoritmaya sahip olduğunuzu varsayalım, önce güçlü bağlı bileşenleri bulabilir, ardından algoritmanızı bu bağlı bileşenlere uygulayabilirsiniz. Döngüler sadece bileşenler içinde var olduğundan, aralarında değil.

Bu sorunu sml (zorunlu programlama) uygulamıştı. İşte taslak. 0 veya bağımsız bir değere sahip tüm düğümleri bulun. Bu düğümler bir döngünün parçası olamaz (bu yüzden onları kaldırın). Ardından, bu düğümlerden gelen veya giden tüm kenarları kaldırın. Bu işlemi ortaya çıkan grafiğe tekrar tekrar uygulayın. Sonunda herhangi bir düğüm veya kenar kalmazsa, grafiğin herhangi bir döngüsü yoktur, aksi takdirde vardır.

Bunu yapmanın yolu, ziyaret edilen köşe sayısını sayarak bir Topolojik Sıralama yapmaktır. Bu sayı, DAG'daki toplam köşe sayısından azsa, bir döngünüz olur.

/mathpro/16393/finding-a-cycle-of-fixed-length Bu çözümü 4 uzunluk için en iyisi :)

Fizik sihirbazı da U (V ^ 2) yapmak zorunda olduğunu söylüyor. Sadece O (V) / O (V + E) 'ye ihtiyacımız olduğuna inanıyorum. Grafik bağlıysa, DFS tüm düğümleri ziyaret edecektir. Grafik alt grafikleri bağladıysa, bu alt grafiğin tepe noktasında bir DFS çalıştırdığımızda, bağlı köşeleri bulacağız ve bunları DFS'nin bir sonraki çalışması için dikkate almayacağız. Bu nedenle, her köşe için çalışma olasılığı yanlıştır.

DFS, önceden ziyaret edilmiş bir tepe noktasına işaret eden bir kenar bulursa, orada bir döngünüz vardır.

Söylediğiniz gibi, bir dizi işiniz var, bunun belirli bir sırada yürütülmesi gerekiyor. Topological sortişlerin planlanması için gerekli sipariş verildiyse (veya a bağımlılık sorunları varsa direct acyclic graph). dfsBir listeyi çalıştırın ve saklayın ve listenin başında düğüm eklemeye başlayın ve daha önce ziyaret edilmiş bir düğümle karşılaştıysanız. Sonra verilen grafikte bir döngü buldunuz.

Bir grafik bu özelliği karşılıyorsa

|e| > |v| - 1

grafik en azından döngüde içerir.