एक निर्देशित ग्राफ में चक्रों का पता लगाने के लिए सर्वश्रेष्ठ एल्गोरिथ्म

Question

एक निर्देशित ग्राफ के भीतर सभी चक्रों का पता लगाने के लिए सबसे कुशल एल्गोरिदम क्या है?

मेरे पास एक निर्देशित ग्राफ है जो नौकरियों की एक अनुसूची का प्रतिनिधित्व करता है जिसे निष्पादित करने की आवश्यकता है, एक नौकरी नोड और एक निर्भरता एक किनारे होने की आवश्यकता है। मुझे इस ग्राफ के भीतर एक चक्र के त्रुटि मामले का पता लगाने की आवश्यकता है जो चक्रीय निर्भरता के लिए अग्रणी है।

Comments

आप कहते हैं कि आप सभी चक्रों का पता लगाना चाहते हैं, लेकिन आपका उपयोग-मामला बताता है कि यह पता लगाने के लिए पर्याप्त होगा कि क्या कोई चक्र हैं।

— स्टीव जेसप

सभी चक्रों का पता लगाना बेहतर होगा, ताकि वे एक बार में तय किए जा सकें, बजाय चेक, फिक्स, चेक, फिक्स आदि के

— 12

आपको डोनाल्ड बी। जॉनसन द्वारा "एक निर्देशित ग्राफ के सभी प्राथमिक सर्किटों को खोजना" पेपर को पढ़ना चाहिए। यह केवल प्राथमिक सर्किट पाएगा, लेकिन यह आपके मामले के लिए पर्याप्त होना चाहिए। और यहां मेरा जावा कार्यान्वयन इस एल्गोरिदम का उपयोग करने के लिए तैयार है: github.com/1123/johnson

— user152468

एल्गोरिथ्म के लिए अतिरिक्त संशोधन के साथ DFS चलाएँ: आपके द्वारा देखे गए प्रत्येक नोड को चिह्नित करें। यदि आप एक नोड पर जाते हैं जो पहले से ही दौरा किया है, तो आपके पास एक पुटी है। जब आप किसी पथ से पीछे हटते हैं, तो आने वाले नोड्स को चिह्नित करें।

— हेशम यासिन

@HeshamYassin, यदि आप पहले से ही एक नोड पर जाते हैं, तो इसका मतलब यह नहीं है कि वहाँ एक लूप है। कृपया मेरी टिप्पणी cs.stackexchange.com/questions/9676/… पढ़ें ।

— दिमित्री

Answer 1

टारजन के दृढ़ता से जुड़े घटकों एल्गोरिथ्म में O(|E| + |V|)समय की जटिलता है।

अन्य एल्गोरिदम के लिए, विकिपीडिया पर मजबूती से जुड़े घटकों को देखें ।

Comments

दृढ़ता से जुड़े घटकों को खोजने से आपको ग्राफ़ में मौजूद चक्रों के बारे में कैसे पता चलता है?

— पीटर

हो सकता है कि कोई पुष्टि कर सकता है लेकिन टारजन एल्गोरिथ्म ए-> ए की तरह सीधे खुद को इंगित करने वाले नोड्स के चक्रों का समर्थन नहीं करता है।

— सेड्रिक गुइलेमेट

@Cedrik राइट, सीधे नहीं। यह टारजन के एल्गोरिथ्म में कोई दोष नहीं है, लेकिन इस प्रश्न के लिए इसका उपयोग किया जाता है। टारजन को सीधे साइकिल नहीं मिलती है , यह दृढ़ता से जुड़े घटकों को ढूंढता है। बेशक, 1 से अधिक आकार वाले किसी भी SCC का मतलब एक चक्र है। गैर-चक्रीय घटकों में एक एकल SCC है। समस्या यह है कि एक आत्म-लूप भी अपने आप ही SCC में चला जाएगा। तो आपको सेल्फ-लूप के लिए एक अलग चेक की जरूरत है, जो कि बहुत मामूली है।

— मोगाका

(ग्राफ में सभी दृढ़ता से जुड़े हुए घटक)! = (ग्राफ के सभी चक्र)

— optimusfrenk

@ अंकु: एक तीन रंग डीएफएस में भी एक ही रनटाइम है O(|E| + |V|)। सफेद (कभी नहीं देखा गया) का उपयोग करते हुए, ग्रे (वर्तमान नोड का दौरा किया जाता है लेकिन सभी पहुंच योग्य नोड्स का अभी तक दौरा नहीं किया गया है) और काले (सभी पहुंच योग्य नोड्स वर्तमान के साथ-साथ देखे गए हैं) रंग कोडिंग, अगर एक ग्रे नोड एक और ग्रे नोड पाता है तो हम ' एक चक्र है। [सुंदर है कि हम कॉर्मेन एल्गोरिथ्म पुस्तक में क्या है]। आश्चर्य है कि क्या 'टारजन के एल्गोरिथ्म' का ऐसे डीएफएस पर कोई लाभ है !!

— केजहतक

Answer 2

यह देखते हुए कि इस नौकरियों का एक कार्यक्रम है, मुझे लगता है कि कुछ बिंदु पर आप करने जा रहे हैं प्रकार उन्हें निष्पादन के प्रस्तावित क्रम में ।

यदि ऐसा है, तो एक टोपोलॉजिकल प्रकार का कार्यान्वयन किसी भी मामले में चक्रों का पता लगा सकता है। UNIX tsortनिश्चित रूप से करता है। मुझे लगता है कि यह संभावना है कि इसलिए एक अलग चरण के बजाय एक ही समय में tsorting के रूप में चक्रों का पता लगाना अधिक कुशल है।

तो सवाल बन सकता है, "मैं सबसे कुशलतापूर्वक tsort कैसे करूं", बजाय "मैं सबसे कुशलतापूर्वक छोरों का पता कैसे लगाता हूं"। जिसके लिए उत्तर शायद "एक पुस्तकालय का उपयोग करें" है, लेकिन निम्नलिखित विकिपीडिया लेख को विफल कर रहा है:

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

एक एल्गोरिथ्म के लिए छद्म कोड है, और टारजन से दूसरे का संक्षिप्त विवरण है। दोनों में O(|V| + |E|)समय की जटिलता है।

Comments

एक टोपोलॉजिकल प्रकार चक्रों का पता लगा सकता है, क्योंकि यह गहराई-पहले खोज एल्गोरिथ्म पर निर्भर करता है, लेकिन आपको वास्तव में चक्रों का पता लगाने के लिए अतिरिक्त बहीखाता की आवश्यकता होती है। देखें कर्ट पीक का सही जवाब।

— ल्यूक हचिसन

Answer 3

इसे करने का सबसे सरल तरीका ग्राफ की गहराई से पहले ट्रैवर्सल (डीएफटी) करना है ।

यदि ग्राफ़ में nकोने हैं, तो यह एक O(n)समय जटिलता एल्गोरिथम है। चूंकि आपको संभवतः प्रत्येक शीर्ष से शुरू होने वाले डीएफटी को करना होगा, कुल जटिलता बन जाती हैO(n^2) ।

आपको वर्तमान गहराई पहले ट्रैवर्सल में सभी कोने वाले एक स्टैक को बनाए रखना होगा , इसका पहला तत्व रूट नोड होगा। यदि आप एक ऐसे तत्व के पार आते हैं जो पहले से ही डीएफटी के दौरान स्टैक में है, तो आपके पास एक चक्र है।

Comments

यह "नियमित" ग्राफ के लिए सही होगा, लेकिन एक निर्देशित ग्राफ के लिए गलत है । उदाहरण के लिए, चार नोड्स के साथ "डायमंड डिपेंडेंसी डायग्राम" पर विचार करें: ए, बी और सी की ओर इशारा करने वाले किनारों के साथ, जिनमें से प्रत्येक के पास डी की ओर इशारा करते हुए एक किनारे है। ए से इस आरेख के आपके डीएफटी ट्रैवर्सल गलत तरीके से निष्कर्ष निकालेंगे कि "लूप" था वास्तव में एक चक्र है - हालांकि एक लूप है, यह एक चक्र नहीं है क्योंकि यह तीरों का पालन करके ट्रैवर्स नहीं किया जा सकता है।

— पीटर

@ आप बता सकते हैं कि ए से डीएफटी गलत तरीके से कैसे निष्कर्ष निकालेंगे कि एक चक्र है?

— दीपक

@Deepak - वास्तव में, मैंने "भौतिक जादूगर" से उत्तर को गलत बताया: जहां उन्होंने "स्टैक में लिखा था" मुझे लगा "पहले से ही मिल गया है"। यह वास्तव में पर्याप्त होगा (एक निर्देशित लूप का पता लगाने के लिए) डीएफटी के निष्पादन के दौरान "स्टैक" में डूप्स की जांच करने के लिए। आप में से प्रत्येक के लिए एक उत्थान।

— पीटर

आप यह क्यों कहते हैं कि समय की जटिलता यह है O(n)कि आप यह देखने के लिए स्टैक की जाँच करने का सुझाव देते हैं कि क्या उसमें पहले से ही एक नोड है? स्टैक O(n)को स्कैन करना रनटाइम के लिए समय जोड़ता है क्योंकि इसे प्रत्येक नए नोड पर स्टैक को स्कैन करना पड़ता है। आप प्राप्त कर सकते हैं O(n)यदि आप नोड्स का दौरा किया

— जेम्स Wierzba

जैसा कि पीटर ने कहा, यह निर्देशित रेखांकन के लिए अधूरा है। देखें कर्ट पीक का सही जवाब।

— ल्यूक हचिसन

Answer 4

कॉर्मेन एट अल। के लेम्मा 22.11 के अनुसार , एल्गोरिदम का परिचय (CLRS):

एक निर्देशित ग्राफ जी एसाइक्लिक है यदि और केवल अगर जी की गहराई-पहली खोज से कोई बैक एज नहीं निकलता है।

इसका उल्लेख कई उत्तरों में किया गया है; यहाँ मैं CLRS के अध्याय 22 के आधार पर एक कोड उदाहरण भी प्रदान करूँगा। उदाहरण ग्राफ नीचे सचित्र है।

गहराई से खोज के लिए CLRS का छद्म कोड पढ़ता है:

सीएलआरएस चित्रा 22.4 में उदाहरण में, ग्राफ में दो डीएफएस पेड़ शामिल हैं: एक में नोड यू , वी , एक्स , और वाई और नोड्स डब्ल्यू और जेड के अन्य शामिल हैं । प्रत्येक पेड़ में एक बैक एज होता है: एक x से v तक और दूसरा z से z तक (एक आत्म पाश)।

प्रमुख बोध यह है कि एक बैक एज का सामना तब होता है, जब DFS-VISITफ़ंक्शन में, पड़ोसी vके साथ पुनरावृत्ति करते हुए u, नोड के साथ सामना किया जाता हैGRAY रंग के ।

निम्नलिखित पायथन कोड CLRS 'pseudocode का एक ifक्लॉज जोड़ा गया है जो चक्रों का पता लगाता है:

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)

ध्यान दें कि इस उदाहरण में, time CLRS के छद्मकोड पर कब्जा नहीं किया गया है क्योंकि हम केवल चक्रों का पता लगाने में रुचि रखते हैं। किनारों की सूची से ग्राफ के आसन्न सूची प्रतिनिधित्व के निर्माण के लिए कुछ बॉयलरप्लेट कोड भी है।

जब इस स्क्रिप्ट को निष्पादित किया जाता है, तो यह निम्न आउटपुट प्रिंट करता है:

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

ये CLRS चित्रा 22.4 में उदाहरण में बिल्कुल पीछे के किनारे हैं।

Comments

यह एकमात्र संबंधित, स्वीकार्य और काम करने वाला उत्तर है, जो बहुत अधिक उत्थान के योग्य है।

— plasmacel

Answer 5

DFS से शुरू करें: यदि DFS के दौरान बैक-एज की खोज की जाती है, तो केवल एक चक्र मौजूद होता है । यह सफेद-मार्ग प्रमेय के परिणामस्वरूप सिद्ध होता है।

Comments

हां, मुझे लगता है कि ऐसा ही है, लेकिन यह पर्याप्त नहीं है, मैं अपना रास्ता cs.stackexchange.com/questions/7216/find-the-simple-cycles-in-a-directed-graph

— jonapriver

सच। अजय गर्ग केवल "चक्र" को खोजने के बारे में बता रहे हैं, जो इस प्रश्न का एक उत्तर है। आपका लिंक पूछे गए प्रश्न के अनुसार सभी चक्रों को खोजने के बारे में बात करता है, लेकिन फिर से ऐसा लगता है कि यह अजय गर्ग के समान दृष्टिकोण का उपयोग करता है, लेकिन सभी संभव dfs- पेड़ भी करता है।

— मनोहर रेड्डी पोरेड्डी

यह निर्देशित ग्राफ़ के लिए अधूरा है। देखें कर्ट पीक का सही जवाब।

— ल्यूक हचिसन

Answer 6

मेरी राय में, एक निर्देशित ग्राफ में चक्र का पता लगाने के लिए सबसे समझ में आने वाला एल्गोरिदम ग्राफ़-कलर-एल्गोरिथ्म है।

मूल रूप से, ग्राफ़िकल कलरिंग एल्गोरिथ्म ग्राफ़ को डीएफएस तरीके (डेप्थ फ़र्स्ट सर्च, जिसका अर्थ है कि यह किसी अन्य मार्ग की खोज करने से पहले पूरी तरह से एक पथ की खोज करता है) पर चलता है। जब यह एक बैक एज पाता है, तो यह एक लूप युक्त ग्राफ को चिह्नित करता है।

ग्राफ़िक्स रंग एल्गोरिथ्म की गहराई से व्याख्या के लिए, कृपया इस लेख को पढ़ें: http://www.geeksforgeeks.org/detect-cycle-direct-graph-use-colors/

इसके अलावा, मैं जावास्क्रिप्ट https://github.com/dexcodeinc/graph_algorithm.js/blob/master/graph_algorithm.js में ग्राफ रंगिंग का कार्यान्वयन प्रदान करता हूं

Answer 7

यदि आप नोड्स में "विज़िट की गई" संपत्ति नहीं जोड़ सकते हैं, तो एक सेट (या मैप) का उपयोग करें और सेट में सभी विज़िट किए गए नोड्स को तब तक जोड़ें जब तक कि वे सेट में पहले से ही न हों। "कुंजी" के रूप में एक अद्वितीय कुंजी या वस्तुओं के पते का उपयोग करें।

यह आपको चक्रीय निर्भरता के "रूट" नोड के बारे में भी जानकारी देता है जो तब आएगा जब उपयोगकर्ता को समस्या को ठीक करना होगा।

एक और उपाय यह है कि निष्पादित करने के लिए अगली निर्भरता खोजने की कोशिश करें। इसके लिए, आपके पास कुछ स्टैक होना चाहिए जहाँ आप याद रख सकें कि आप अभी कहाँ हैं और आपको आगे क्या करना है। जाँच करें कि क्या कोई निर्भरता आपके द्वारा निष्पादित करने से पहले ही इस स्टैक पर है। यदि यह है, तो आपको एक चक्र मिला है।

हालांकि यह O (N * M) की जटिलता हो सकती है, आपको याद रखना चाहिए कि स्टैक की बहुत सीमित गहराई है (इसलिए N छोटा है) और M प्रत्येक निर्भरता से छोटा हो जाता है जिसे आप "निष्पादित" प्लस के रूप में देख सकते हैं। जब आप एक पत्ता मिला तो आप खोज को रोक सकते हैं (इसलिए आप कभी नहीं भी प्रत्येक नोड की जांच करनी होगी -> एम छोटा होगा, भी)।

मेटा मेक में, मैंने ग्राफ़ को सूचियों की सूची के रूप में बनाया और फिर प्रत्येक नोड को हटा दिया क्योंकि मैंने उन्हें निष्पादित किया जो स्वाभाविक रूप से खोज मात्रा में कटौती करते हैं। मुझे वास्तव में कभी भी स्वतंत्र जांच नहीं करनी पड़ी, यह सब सामान्य निष्पादन के दौरान स्वचालित रूप से हुआ।

यदि आपको "केवल परीक्षण" मोड की आवश्यकता है, तो बस एक "ड्राई-रन" ध्वज जोड़ें जो वास्तविक नौकरियों के निष्पादन को अक्षम करता है।

Answer 8

कोई एल्गोरिथ्म नहीं है जो बहुपद समय में एक निर्देशित ग्राफ में सभी चक्रों को पा सकता है। मान लीजिए, निर्देशित ग्राफ में n नोड्स हैं और प्रत्येक जोड़ी नोड्स में एक दूसरे से कनेक्शन हैं, जिसका अर्थ है कि आपके पास पूरा ग्राफ़ है। तो इन n नोड्स में से कोई भी गैर-रिक्त उपसमूह एक चक्र को इंगित करता है और ऐसे उप-संख्याओं के 2 ^ n-1 नंबर हैं। तो कोई बहुपद समय एल्गोरिथ्म मौजूद नहीं है। तो मान लें कि आपके पास एक कुशल (गैर-बेवकूफ) एल्गोरिथ्म है जो आपको एक ग्राफ में निर्देशित चक्रों की संख्या बता सकता है, आप पहले मजबूत जुड़े घटकों को पा सकते हैं, फिर इन कनेक्टेड घटकों पर अपने एल्गोरिथ्म को लागू कर सकते हैं। चूंकि चक्र केवल घटकों के भीतर ही मौजूद हैं, न कि उनके बीच।

Comments

सच है, अगर नोड की संख्या इनपुट के आकार के रूप में ली जाती है। आप किनारों की संख्या या यहां तक ​​कि चक्र, या इन उपायों के संयोजन के संदर्भ में रनटाइम जटिलता का भी वर्णन कर सकते हैं। डोनाल्ड बी। जॉनसन द्वारा एल्गोरिथ्म "एक निर्देशित ग्राफ के सभी प्राथमिक परिपथों को खोजना" ओ ((n + e) ​​(c + 1) द्वारा दिया गया बहुपद चल रहा समय है जहाँ n नोड्स की संख्या है, किनारों की संख्या और ग्राफ के प्राथमिक सर्किटों की संख्या। और यहाँ इस एल्गोरिथ्म का मेरा जावा कार्यान्वयन है: github.com/1123/johnson ।

— user152468

Answer 9

मैंने इस समस्या को sml (अनिवार्य प्रोग्रामिंग) में लागू किया था। यहाँ रूपरेखा है। सभी नोड्स खोजें जो या तो एक इन्डेग्री या आउटडेग्री 0 के हैं। इस तरह के नोड्स एक चक्र का हिस्सा नहीं हो सकते हैं (इसलिए उन्हें हटा दें)। अगले ऐसे नोड्स से आने वाले सभी या बाहर जाने वाले किनारों को हटा दें। परिणामी ग्राफ़ पर इस प्रक्रिया को पुन: लागू करें। यदि अंत में आपको किसी भी नोड या किनारे के साथ नहीं छोड़ा जाता है, तो ग्राफ में कोई चक्र नहीं है, इसके अलावा यह है।

Answer 10

जिस तरह से मैं कर रहा हूं वह एक टोपोलॉजिकल सॉर्ट करना है, जो की जाने वाली संख्याओं की गिनती करता है। यदि वह संख्या DAG में कुल संख्या से कम है, तो आपके पास एक चक्र है।

Comments

इसका कोई मतलब नहीं निकलता। यदि ग्राफ़ में चक्र हैं, तो कोई टोपोलॉजिकल सॉर्टिंग नहीं है, जिसका अर्थ है कि टोपोलॉजिकल सॉर्टिंग के लिए कोई भी सही एल्गोरिदम गर्भपात करेगा।

— सेल्के सिप

विकिपीडिया से: कई टोपोलॉजिकल सॉर्टिंग एल्गोरिदम चक्रों का भी पता लगाएंगे, क्योंकि वे टोपोलॉजिकल ऑर्डर के अस्तित्व में आने में बाधा हैं।

— ओलेग मिखेव

@OlegMikheev हाँ, लेकिन स्टीव कह रहे हैं "यदि वह संख्या DAG में कुल संख्या से कम है, तो आपके पास एक चक्र है", जिसका कोई मतलब नहीं है।

— नबंर

@nbro मैं शर्त लगाऊंगा, उनका मतलब है कि टोपोलॉजिकल सॉर्टिंग एल्गोरिथ्म का एक प्रकार जो गर्भपात तब होता है जब कोई टोपोलॉजिकल सॉर्टिंग मौजूद नहीं होता है (और फिर वे सभी कोने पर नहीं जाते हैं)।

— Maaartinus

यदि आप चक्र के साथ एक ग्राफ पर एक टोपोलॉजिकल सॉर्टिंग करते हैं, तो आप एक आदेश के साथ समाप्त हो जाएंगे जिसमें खराब किनारों की कम से कम मात्रा (ऑर्डर संख्या> पड़ोसी की क्रम संख्या) है। लेकिन आपको उन खराब किनारों का पता लगाने के लिए इसकी छँटाई करने के बाद एक चक्र के साथ एक ग्राफ का पता लगाने के परिणामस्वरूप

— UGP

Answer 11

/mathpro/16393/finding-a-cycle-of-fixed-length मुझे यह समाधान 4 लंबाई के लिए विशेष रूप से पसंद है :)

इसके अलावा भौतिक जादूगर का कहना है कि यू को ओ (वी ^ 2) करना है। मेरा मानना ​​है कि हमें केवल O (V) / O (V + E) की आवश्यकता है। यदि ग्राफ़ जुड़ा हुआ है तो DFS सभी नोड्स पर जाएगा। यदि ग्राफ़ ने उप ग्राफ़ को कनेक्ट किया है, तो हर बार जब हम इस सब ग्राफ़ के एक शीर्ष पर एक डीएफएस चलाते हैं तो हम जुड़े हुए कोने पाएंगे और उन्हें डीएफएस के अगले रन के लिए इन पर विचार करना होगा। इसलिए प्रत्येक शीर्ष के लिए चलने की संभावना गलत है।

Answer 12

यदि डीएफएस को एक किनारा मिलता है जो पहले से देखे गए शीर्ष बिंदु पर इंगित करता है, तो आपके पास वहां एक चक्र है।

Comments

1,2,3: 1,2 पर विफल; 1,3; 2,3;

— शोर बिल्ली

@JakeGreene यहां देखें: i.imgur.com/tEkM5xy.png समझने के लिए सरल है। आप कहते हैं कि आप 0. से शुरू करते हैं। फिर आप नोड 1 पर जाते हैं, वहां से कोई रास्ता नहीं है, फिर से वापस जाना है। अब आप नोड 2 पर जाते हैं, जिसमें शीर्ष 1 पर एक छोर है, जो पहले से ही दौरा किया गया था। आपकी राय में आपके पास तब एक चक्र होगा - और आपके पास वास्तव में एक नहीं है

— शोर बिल्ली

@kittyPL उस ग्राफ़ में एक चक्र नहीं है। विकिपीडिया से: "एक निर्देशित ग्राफ में एक निर्देशित चक्र एक ही शीर्ष पर शुरू होने और समाप्त होने का क्रम है, जैसे कि चक्र के प्रत्येक दो लगातार कोने के लिए, पहले किनारे से बाद में एक तक निर्देशित एक धार मौजूद है" वी से एक मार्ग का अनुसरण करने में सक्षम होना चाहिए जो एक निर्देशित चक्र के लिए वी की ओर जाता है। mafonya का समाधान दी गई समस्या के लिए काम करता है

— जेक ग्रीन

@JakeGreene बेशक यह नहीं करता है। अपने एल्गोरिथ्म का उपयोग करना और 1 से शुरू करना आपको वैसे भी एक चक्र का पता लगाएगा ... यह एल्गोरिथ्म सिर्फ बुरा है ... आमतौर पर जब भी आप किसी विज़िट किए गए शीर्ष पर आते हैं तो पीछे की ओर चलना पर्याप्त होगा।

— शोर बिल्ली

@ किटीपीएल डीएफएस दिए गए शुरुआती नोड से चक्रों का पता लगाने के लिए काम करता है। लेकिन डीएफएस करते समय आपको बैक-एज से क्रॉस-एज को अलग करने के लिए नोड्स का रंग होना चाहिए। पहली बार एक शीर्ष पर जाकर यह ग्रे हो जाता है, फिर आप इसे काला कर देते हैं जब इसके सभी किनारों का दौरा किया जाता है। यदि DFS करते समय आप एक ग्रे वर्टेक्स से टकराते हैं तो वह वर्टेक्स पूर्वज होता है (यानी: आपके पास एक चक्र है)। यदि शीर्ष काला है तो यह केवल एक क्रॉस-एज है।

— किर्रा

Answer 13

जैसा कि आपने कहा, आपके पास नौकरियों का सेट है, इसे निश्चित क्रम में निष्पादित करने की आवश्यकता है। Topological sortआपको नौकरियों के समयबद्धन (या यदि यह निर्भरता की समस्याओं के लिए आवश्यक है) के लिए आवश्यक आदेश दिया गया है direct acyclic graph। चलाएँ dfsऔर एक सूची बनाए रखें, और सूची की शुरुआत में नोड जोड़ना शुरू करें, और यदि आपने एक नोड का सामना किया है जो पहले से ही दौरा किया गया है। फिर आपको दिए गए ग्राफ में एक चक्र मिला।

Answer 14

यदि एक ग्राफ इस संपत्ति को संतुष्ट करता है

|e| > |v| - 1

तब ग्राफ में कम से कम चक्र होता है।

Comments

यह अप्रत्यक्ष रेखांकन के लिए सही हो सकता है, लेकिन निश्चित रूप से निर्देशित रेखांकन के लिए नहीं।

— हंस-पीटर स्टॉर

एक काउंटर उदाहरण A-> B, B-> C, A-> C होगा।

— user152468

सभी कोने में किनारे नहीं हैं।

— देबंजन धर