क्या DAG एक सकर्मक कमी है?


11

इस चुनौती का लक्ष्य एक परिमित निर्देशित एसाइक्लिक ग्राफ (DAG) दिया गया है, यह निर्धारित करें कि क्या ग्राफ एक सकर्मक कमी है

एक डीएजी और सकर्मक कटौती के बारे में संक्षिप्त विवरण:

एक डीएजी निर्देशित किनारों के साथ एक ग्राफ है (यानी आप उस किनारे पर केवल एक दिशा में यात्रा कर सकते हैं) जैसे कि ग्राफ पर कोई भी शुरुआती नोड दिया गया है, प्रारंभिक नोड पर लौटना असंभव है (यानी कोई चक्र नहीं हैं)।

किसी भी शुरुआती नोड को देखते हुए, यदि किसी भी मनमाने ढंग से सकारात्मक किनारों के माध्यम से ग्राफ में एक और समाप्ति नोड की यात्रा करना संभव है, तो उस नोड को प्रारंभिक नोड से पहुंच योग्य के रूप में परिभाषित किया गया है। एक सामान्य DAG में, कई रास्ते हो सकते हैं जो एक शुरुआती नोड से एक लक्ष्य समाप्ति नोड तक ले जा सकते हैं। उदाहरण के लिए, इस हीरे का ग्राफ लें:

यहाँ छवि विवरण दर्ज करें

नोड के लिए प्राप्त करने के लिए Dसे A, आप पथ ले सकता है A->B->Dया A->C->D। इस प्रकार, Dसे उपलब्ध है A। हालांकि, कोई रास्ता नहीं है जो नोड से Bशुरू होने वाले नोड तक ले जाया जा सकता है C। इस प्रकार, नोड नोड Bसे उपलब्ध नहीं है C

ग्राफ़ में प्रत्येक प्रारंभिक नोड के लिए पहुंच योग्य नोड्स की सूची के रूप में ग्राफ की पुनःचुन्यता को परिभाषित करें । तो एक ही उदाहरण के लिए हीरे का ग्राफ, अभिकर्मक है:

A: [B, C, D]
B: [D]
C: [D]
D: []

एक अन्य ग्राफ, जिसमें उपरोक्त ग्राफ के समान ही रिस्पांसबिलिटी है, नीचे दिखाया गया है:

यहाँ छवि विवरण दर्ज करें

हालांकि, इस दूसरे ग्राफ में मूल ग्राफ की तुलना में अधिक किनारे हैं। एक ग्राफ की सकर्मक कमी एक ऐसा ग्राफ है जिसमें कम से कम किनारों की संख्या और मूल ग्राफ की समान पुनरावृत्ति है। तो पहला ग्राफ दूसरे की सकर्मक कमी है।

एक परिमित DAG के लिए, सकर्मक कमी अस्तित्व में है और अद्वितीय है।

इनपुट

इनपुट "सूचियों की सूची" है, जहां बाहरी सूची में कोने की संख्या होती है, और प्रत्येक आंतरिक सूची में संबद्ध नोड को छोड़कर किनारों की संख्या होती है, और गंतव्य नोड्स के सूचकांक होते हैं। उदाहरण के लिए, ऊपर दिए गए पहले ग्राफ का वर्णन करने का एक तरीका होगा (शून्य आधारित अनुक्रमण को मानते हुए):

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

आप किसी भी पूर्णांक पूर्णांक मान (जैसे 0 या 1 आधारित अनुक्रमणिका) पर पहले नोड का अनुक्रमण शुरू कर सकते हैं।

इनपुट वांछित (stdio, फ़ंक्शन पैरामीटर, आदि) से किसी भी इनपुट स्रोत से आ सकता है। जब तक कोई अतिरिक्त जानकारी नहीं दी जाती है, आप सटीक इनपुट प्रारूप चुनने के लिए स्वतंत्र हैं। उदाहरण के लिए, यदि आप stdio से इनपुट लेना चाहते हैं, तो आपके पास संबंधित नोड के लिए प्रत्येक पंक्ति किनारों की एक सूची हो सकती है। पूर्व .:

1 2
3
3
'' (blank line)

प्रत्येक आसन्न सूची में सूचकांकों को आवश्यक रूप से क्रमबद्ध नहीं किया गया है, और दो नोड्स (उदा [[1,1],[]]. :) को जोड़ने वाले कई किनारे हो सकते हैं । आप मान सकते हैं कि इनपुट ग्राफ कमजोर रूप से जुड़ा हुआ है , और इसमें कोई चक्र नहीं है (यानी यह एक डीएजी है)।

उत्पादन

आउटपुट सत्य है यदि दिए गए इनपुट DAG एक सकर्मक कमी है, और एक मिथ्या मूल्य अन्यथा। यह वांछित किसी भी सिंक (stdio, रिटर्न वैल्यू, आउटपुट पैरामीटर, आदि) के लिए हो सकता है

उदाहरण

सभी उदाहरण 0-आधारित अनुक्रमण का उपयोग करते हैं।

[[1,2],[3],[3],[]]
true

[[1,2,3],[3],[3],[]]
false

[[1,1],[]]
false

[[1,2,3,4],[5,6,7],[5,8,9],[6,8,10],[7,9,10],[11,12],[11,13],[12,13],[11,14],[12,14],[13,14],[],[],[],[]]
true

[[5,6,7],[2,3,0,4],[5,8,9],[6,8,10],[7,9,10],[11,12],[11,13],[12,13],[11,14],[12,14],[13,14],[],[],[],[]]
true

[[5,6,7],[2,3,0,4,14,5,7],[5,8,9],[6,8,10],[7,9,10],[11,12],[11,13],[12,13],[11,14],[12,14],[13,14],[],[],[],[]]
false

[[5,6,7],[2,3,0,4],[5,8,9],[6,8,10],[7,9,10,14],[11,12],[11,13],[12,13],[11,14],[12,14],[13,14],[],[],[],[]]
false

[[1,3],[2],[3],[]]
false

स्कोरिंग

यह कोड गोल्फ है; बाइट्स में सबसे छोटा कोड जीतता है। आपका कोड उचित समय में पूरा होना चाहिए (आपके पास जो भी हार्डवेयर है उस पर 10 मिनट अधिकतम)। मानक खामियां लागू होती हैं। आप किसी भी बिल्ट-इन का उपयोग कर सकते हैं।


क्या हम इनपुट की कनेक्टिविटी के बारे में कोई धारणा बना सकते हैं? (मैंने आपके सभी परीक्षण मामलों की जाँच नहीं की है, लेकिन क्या वे ग्राफ़ के कई डिस्कनेक्ट किए गए भागों को कवर करते हैं?)
मार्टिन एंडर

जो मैं मानता हूं, वह सही भाषा है।
helloworld922

मुझे लगता है कि यह ठीक है। आप यह भी कह सकते हैं कि ग्राफ कमजोर रूप से जुड़ा हुआ है
मार्टिन एंडर

जवाबों:


5

रूबी, 101 97 बाइट्स

सरल दृष्टिकोण जो प्रत्येक नोड से पहुंच की गणना करता है और विचार करता है कि क्या बच्चे के नोड को किसी अन्य नोड के माध्यम से पहुँचा जा सकता है। चक्रीय रेखांकन पर विफल रहता है, लेकिन एक DAG की परिभाषा का अर्थ है कि यह चक्रीय रास्ते नहीं होना चाहिए।

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

->g{r=->i{i|i.map{|j|r[g[j]||[]]}.inject([],:|)}
g.all?{|e|e==e&e&&e.none?{|i|r[e-[i]].index i}}}

4

मैथेमेटिका, 95 82 बाइट्स

@MartinEnder की वजह से 13 बाइट बच गईं

#~IsomorphicGraphQ~TransitiveReductionGraph@#&@Graph[x=0;##&@@Thread[++x->#]&/@#]&

अनाम फ़ंक्शन। (1-आधारित) इनपुट के रूप में एक नेस्टेड सूची लेता है, और रिटर्न Trueया Falseआउटपुट के रूप में। यहां मुख्य समाधान 46-बाइट है #~IsomorphicGraphQ~TransitiveReductionGraph@#&, जो परीक्षण करता है यदि किसी दिए गए ग्राफ को इसके संक्रामक कमी के लिए आइसोमोर्फिक है। बाकी इनपुट को Graphऑब्जेक्ट में कनवर्ट करता है ।


3

CJam (41 बाइट्स)

q~:A_,{{Af=e__&}%_}*]:.|A.&A:$:e`e_2%1-*!

ऑनलाइन डेमो , परीक्षण दोहन

विच्छेदन

q~:A      e# Parse input and store in A
_,{       e# Loop V times
  {       e#   Extend adjacency list representation of G^i to G^(i+1)
    Af=   e#   by extending each path by one edge
    e__&  e#   and flattening. NB :| would be shorter but breaks for empty lists
  }%
  _       e#   Duplicate, so that we build up G^2, G^3, ..., G^n
}*]       e# Gather in a single array
:.|       e# Fold pointwise union, giving the reachability from each vertex by
          e# paths of length > 1
A.&       e# Pointwise intersect with the paths of length 1
          e# We hope to get an array of empty arrays

          e# Handle the awkward special case of duplicate edges:
A:$       e# Sort each adjacency list
:e`       e# Run-length encode each adjacency list
e_2%      e# Extract only the run lengths
1-        e# Discard the 1s - so we now have an empty array unless there's a dupe

*         e# Join. We hope to be joining an array of empty arrays by an empty array
          e# giving an empty array
!         e# Check that we get a falsy value (i.e. the empty array)

3

जेली, 20 बाइट्स

ị³$ÐĿ€ị@Fœ&¥";œ-Q$€E

1-आधारित अनुक्रमण का उपयोग करता है। इसे ऑनलाइन आज़माएं!

ढीला अवलोकन

     €                for each vertex,
ị³$ÐĿ                   compute its reach.
        Fœ&¥"         intersect each vertex's lists of children and
      ị@                children's reaches.
             ;        then concatenate the list of intersections with
              œ-Q$€     all duplicate edges in the original graph.
                   E  are all elements equal? checks that all are empty lists,
                        meaning empty intersections and no duplicates.
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.