2010-07-31 10 views
6

मेरे पास एक अप्रत्यक्ष असीमित ग्राफ जी = (वी, ई) और इसके शिखर के यादृच्छिक रूप से चुने गए सबसेट एस हैं। मैं यह जांचना चाहता हूं कि एस में शिखर पारस्परिक रूप से आसन्न हैं (यानी एक पूर्ण उपग्राफ/एक क्लिक्स बनाएं)।

मैं निम्नलिखित एल्गोरिथ्म (छद्म कोड) है:एक प्रेरित सबग्राफ पूरा होने पर यह पता लगाने के लिए फास्ट एल्गोरिदम

foreach vertex in S { 
    // Check that the vertex has enough edges 
    if (vertex.edges.count < S.size - 1) 
    return false; 

    // Check that there is an edge to each vertex in S 
    foreach vertex2 in S { 
    if (!vertex.hasEdgeTo(vertex2)) 
     return false; 
    } 
} 
return true; 

समस्या यह है कि इस एल्गोरिथ्म के बुरी से बुरी हालत प्रदर्शन हे है (| वी |) (मामले में सबसेट एस सभी शामिल हैं जब एक पूर्ण ग्राफ के शिखर)।

मेरा प्रश्न है: क्या एक तेज एल्गोरिदम है जो एक बेहतर बड़ी ओ सबसे बुरी स्थिति जटिलता के साथ चलता है?

+0

क्या आपका मतलब _O (| वी | ²) _ नहीं है? – Svante

+1

आप केवल एक बार प्रत्येक किनारे की जांच करके निरंतर कारक को रोक सकते हैं। इसके लिए, आंतरिक लूप केवल उन सभी शीर्षकों के माध्यम से चलना चाहिए जो अभी तक बाहरी में नहीं हैं। यह निश्चित रूप से बेहतर _O_ जटिलता नहीं देता है। – Svante

+0

हां, ओ (| ई |^2) के बजाय ओ (| वी |^2) है, इसे ठीक किया गया है। मुझे पता है कि मैं आधा समय कर सकता हूं, स्पष्टता के लिए छोड़ दिया। आपकी टिप्पणियों के लिए आभार। –

उत्तर

4

यह मानते हुए कि आप O(1) में दो चरम घटनाएं हैं या नहीं, आपके एल्गोरिदम में सबसे खराब मामले में O(|V|²) = O(|E|) समय जटिलता है। मुझे नहीं लगता कि आप O(|E|) से बेहतर कर सकते हैं, क्योंकि आपको वास्तव में सबग्राफ के सभी किनारों की जांच करनी चाहिए।

+0

सोचा था कि ... मैं एक अच्छी चाल की उम्मीद कर रहा था जो संभवतः इसे ओ (| वी | लॉग (| वी |) बना देगा, लेकिन ऐसा लगता है कि मुझे इसे इस पर चिपकना होगा। –

+1

@dark_charlie ठीक है, जबकि आप शायद 'ओ (| एस | ²)' सबसे बुरी स्थिति समय जटिलता को हरा नहीं सकता है, फिर भी आप कई चालों का उपयोग करके अपने एल्गोरिदम के औसत चलने वाले समय को तेज कर सकते हैं। जो दिमाग में आता है वह है: 'x .hasEdgeTo (y) 'ऐसे आदेश में प्रश्न जो विफल होने की संभावना सबसे पहले पूछे जाते हैं। उदाहरण के लिए आप अपनी डिग्री (' ओ (| एस | लॉग | एस |) 'में आरोही लंबवत क्रमबद्ध कर सकते हैं) निष्पादित करें उस क्रम में बाहरी पाश। – Bolo

2

मुझे विश्वास नहीं है कि आपको यह चेक करने के लिए एक गैर ओ (| ई |^2) एल्गोरिदम मिलेगा। तार्किक रूप से, पूर्णता साबित करने के लिए प्रत्येक V1-V2 किनारे की मांग की जानी चाहिए। दो लूपों में अलग-अलग, किनारे की गणना की पहली जांच और दूसरी बार वर्टेक्स कनेक्शन की जांच करने से संभावित रूप से एल्गोरिदम बढ़ जाएगा। ग्राफ का प्रतिनिधित्व करने का शायद दूसरा तरीका (चरम के बजाय किनारों के साथ) मदद करेगा?

+0

अच्छा बिंदु @ बोलो रे: ओ (| वी |^2) –

+0

आपको क्या लगता है कि इस समस्या के लिए किनारे की सूची/सेट का उपयोग करके ग्राफ का प्रतिनिधित्व करने का लाभ होगा? मुझे कोई अनुभव नहीं है इस तरह के प्रतिनिधित्व के साथ। –

2

आपके hasEdgeTo प्रदर्शन कैसे करता है? यदि आप किनारों को स्टोर करने के लिए पेड़-आधारित सेट का उपयोग करते हैं, तो यह कार्य केवल ओ (1) नहीं है।

किनारों के लिए बिटवेक्टर का उपयोग करके, आप ओ (| एस | * मिनट (| ई |, | वी |, | एस |)) के साथ जा सकते हैं।

+0

हैइजेटो ओ (1) है, मैं एक आसन्न मैट्रिक्स का उपयोग कर रहा हूं। ओ (| एस | * के लिए आपका विचार क्या है मिनट (लॉग (| ई |), | एस |))) एल्गोरिदम? –

+0

@dark_charlie: क्षमा करें, या तो मुझे अब और याद नहीं है जो मैंने कल सोचा था या यह बकवास था। बिटकवेक्टर का लेन या तो होगा | ई | या | वी | (वास्तव में, 8 से विभाजित है क्योंकि आप बिट्स का उपयोग करते हैं)। लेकिन मैं अभी भी सोच रहा हूं कि कोई और प्रतिनिधित्व हो सकता है जो इसे तेज़ी से बनाता है। अगर मुझे कोई विचार आया या फिर याद आए तो मैं वापस लिखूंगा। :) – Albert

संबंधित मुद्दे