मजबूती से जुड़े घटक

Question

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

आपकी चुनौती एक ग्राफ को उसके दृढ़ता से जुड़े घटकों में अलग करना है। विशेष रूप से, आपको ग्राफ़ में सभी SCCs को आउटपुट करना होगा।

मैं / हे:

इनपुट के रूप में, आप निर्देशित किनारों की सूची, एक आसन्न सूची, एक आसन्न मैट्रिक्स, या किसी अन्य उचित इनपुट प्रारूप का उपयोग कर सकते हैं। पूछें कि क्या आपको यकीन नहीं है। आप मान सकते हैं कि ग्राफ में पूरी तरह से काटे गए कोने नहीं हैं, और यह कि कोई स्वयं के किनारे नहीं हैं, लेकिन आप आगे कोई धारणा नहीं बना सकते हैं। आप इनपुट के रूप में वर्टिकल की सूची के साथ-साथ वर्टिकल की संख्या को भी वैकल्पिक रूप से ले सकते हैं।

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

यदि आप एक लेबलिंग का उपयोग करते हैं, तो लेबल या तो लंबवत होना चाहिए, या पूर्णांक का एक निरंतर अनुक्रम होना चाहिए। यह लेबल में कम्प्यूटेशन को रोकने के लिए है।

उदाहरण:

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

इनपुट पहली लाइन पर है, आउटपुट दूसरी लाइन पर है।

[[1, 2], [2, 3], [3, 1], [1, 4]]
[[1, 2, 3], [4]]

[[1, 2], [2, 3], [3, 4]]
[[1], [2], [3], [4]]

[[1, 2], [2, 1], [1, 3], [2, 4], [4, 2], [4, 3]]
[[1, 2, 4], [3]]

[[1, 2], [2, 3], [2, 5], [2, 6], [3, 4], [3, 7], [4, 3], [4, 8], [5, 1], [5, 6], [6, 7], [7, 6], [8, 7], [8, 4]]
[[1, 2, 5], [3, 4, 8], [6, 7]]

स्कोरिंग और प्रतिबंध:

मानक खामियों पर हमेशा की तरह प्रतिबंध लगा दिया जाता है। इसके अलावा, बिल्ट-इन जो विशेष रूप से दृढ़ता से जुड़े घटकों से निपटते हैं, पर प्रतिबंध लगाया जाता है।

समाधान प्रदान किए गए उदाहरणों पर एक घंटे से अधिक नहीं चलने चाहिए। (यह धीमा घातीय समाधानों को रोकने के लिए है, और कुछ नहीं।)

यह कोड गोल्फ है। सबसे कम बाइट्स जीतता है।

Comments

हम एक जुड़े हुए घटक को किस लेबल को लचीला बनाते हैं? उदाहरण के लिए, क्या उस घटक में शीर्ष सूचकांक की सूची एक वैध लेबल होगी?

— xnor

@xnor पूरी तरह से लचीला। समानता परीक्षण / समान तारों के माध्यम से मेल खाना चाहिए।

— isaacg

क्या हमारे ग्राफ इनपुट फॉर्मेट में वर्टिकल और / या वर्टेक्स लेबल की सूची भी हो सकती है?

— xnor

@xnor दोनों के लिए हाँ। मैं इसे संपादित करूँगा।

— isaacg

पिछले परीक्षण के मामले में, मैं 8एक घटक में नहीं हूं, [3,4]क्योंकि यह केवल प्रत्येक 6और 7(जिनमें से कोई भी उस तक नहीं पहुंच सकता है) नहीं कर सकता है ।

— xnor

Answer 1

अजगर 2 सुन्न, 71 62 बाइट्स का उपयोग करते हुए

import numpy
def g(M,n):R=(M+M**0)**n>0;print(R&R.T).argmax(0)

numpyआसन्नता और नोड्स की संख्या का प्रतिनिधित्व करने वाले मैट्रिक्स के रूप में इनपुट लेता है । एक numpyपंक्ति मैट्रिक्स के रूप में आउटपुट उत्पन्न करता है जो प्रत्येक घटक को उसके घटक में सबसे कम शीर्ष संख्या द्वारा लेबल करता है।

एक आसन्न मैट्रिक्स के लिए M, मैट्रिक्स पावर प्रत्येक स्टार्ट वर्टेक्स से प्रत्येक एंड वर्टेक्स तक -स्टेप रास्तों M**nकी संख्या को गिनाती है n। करने के लिए पहचान जोड़ने Mके माध्यम से M+M**0हर किनारे करने के लिए एक आत्म पाश जोड़ने के लिए संशोधित निकटता मैट्रिक्स। तो, (M+M**0)**nलंबाई के पथ को सबसे अधिक n(अतिरेक के साथ) गिना जाता है ।

चूँकि किसी भी पथ की लंबाई सबसे अधिक होती है n, नोड्स की संख्या, (i,j)जहाँ किसी भी शिखर jसे पहुँचा जा सकता iहै, की सकारात्मक प्रविष्टि से मेल खाती है (M+M**0)**n। रीचैबिलिटी मैट्रिक्स तब होता है R=(M+M**0)**n>0, जहां >0एंट्रीवाइज काम करता है।

प्रविष्टि के andरूप में गणना करना R&R.T, जहां R.Tस्थानान्तरण है, फिर एक मैट्रिक्स देता है जो परस्पर पुन: प्राप्त होने वाले जोड़े के जोड़ों को दर्शाता है। यह iवें पंक्ति है एक संकेतक सदिश के रूप में एक ही दृढ़ता से जुड़े घटक में कोने के लिए। इसकी argmaxप्रत्येक पंक्ति को लेते हुए इसमें पहले का सूचकांक Trueदिया जाता है, जो कि इसके घटक में सबसे छोटे शीर्ष का सूचकांक है।

Answer 2

जावास्क्रिप्ट (ईएस 6), 125 बाइट्स

a=>a.map(([m,n])=>(e[m]|=1<<n|e[n],e.map((o,i)=>o&1<<m?e[i]|=e[m]:0)),e=[])&&e.map((m,i)=>e.findIndex((n,j)=>n&1<<i&&m&1<<j))

एक निर्देशित के रूप में निर्देशित जोड़े की एक सूची लेता है, जबकि परिणाम प्रत्येक शीर्ष के लिए एक सरणी है जो पहले शीर्ष को दृढ़ता से जुड़ा हुआ देता है, जिसे मैं एक मान्य लेबलिंग के रूप में मानता हूं। उदाहरण के लिए, इनपुट के साथ [[1, 2], [2, 3], [2, 5], [2, 6], [3, 4], [3, 7], [4, 3], [4, 8], [5, 1], [5, 6], [6, 7], [7, 6], [8, 7], [8, 4]]यह लौटाता है [, 1, 1, 3, 3, 1, 6, 6, 3](कोई शीर्ष 0 नहीं है; शीर्ष 1, 2 और 5 में लेबल 1; 3, 4 और 8 में लेबल 3 है जबकि 6 और 7 में लेबल 6 है)।

Answer 3

MATL , 26 22 बाइट्स

tnX^Xy+HMY^gt!*Xu!"@f!

यह @ xnor के उत्तर के समान दृष्टिकोण का उपयोग करता है ।

में काम करता है वर्तमान संस्करण (15.0.0) भाषा की।

इनपुट ग्राफ के आसन्न मैट्रिक्स है, अर्धविरामों द्वारा अलग की गई पंक्तियों के साथ। पहले और आखिरी परीक्षण मामले हैं

[0 1 0 1; 0 0 1 0; 1 0 0 0; 0 0 0 0]

[0 1 0 0 0 0 0 0; 0 0 1 0 1 1 0 0; 0 0 0 1 0 0 1 0; 0 0 1 0 0 0 0 1; 1 0 0 0 0 1 0 0; 0 0 0 0 0 0 1 0; 0 0 0 0 0 1 0 0; 0 0 0 1 0 0 1 0]

इसे ऑनलाइन आज़माएं!

t     % implicitly input adjacency matrix. Duplicate
n     % number of elements
X^    % square root
Xy    % identity matrix of that size
+     % add to adjacency matrix
HM    % push size again
Y^    % matrix power
g     % convert to logical values (0 and 1)
t!*   % multiply element-wise by transpose matrix
Xu    % unique rows. Each row is a connected component
!     % transpose
"     % for each column
  @   %   push that column
  f!  %   indices of nonzero elements, as a row
      % end for each. Implicitly display stack contents

Answer 4

पायथ, 13 बाइट्स

.gu+Gs@LQG.{k

प्रदर्शन , टेस्ट सूट

इनपुट एक आसन्न सूची है, जो एक शब्दकोश के रूप में दर्शायी जाती है, जो कोने की सूची में कोने को मैप करती है, जिसके किनारों (इसके निर्देशित पड़ोसी) हैं। आउटपुट एक विभाजन है।

प्रोग्राम का सार यह है कि हम उन वर्टीकल्स के सेट को खोजते हैं जो प्रत्येक वर्टेक्स से उपलब्ध होते हैं, और फिर उन सेट्स के द्वारा वर्टिक्स को समूहित करते हैं। एक ही SCC में किन्हीं भी दो वर्टिकल में से एक समान सेट होता है, जो प्रत्येक से अलग-अलग होता है, क्योंकि प्रत्येक दूसरे से उपलब्ध होता है, और रीचैबिलिटी सकर्मक होती है। अलग-अलग घटकों के किसी भी कोने में अलग-अलग पहुंच योग्य सेट होते हैं, क्योंकि दोनों में से किसी में सेट नहीं होता है।

कोड स्पष्टीकरण:

.gu+Gs@LQG.{k
                  Implicit: Q is the input adjacency list.
.g           Q    Group the vertices of Q by (Q is implicit at EOF)
  u       .{k     The fixed point of the following function, 
                  starting at the set containing just that vertex
   +G             Add to the set
     s            The concatenation of
      @LQG        Map each prior vertex to its directed neighbors