अधिकतम मिलान किनारों का एक सेट खोजें

Question

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

एक मिलान सेट कहा जाता है maximally matching, या maximal matchingयदि मिलान सेट के लिए ग्राफ़ के दूसरे किनारे को जोड़ना असंभव है। तो ऊपर दिए गए दोनों उदाहरण अधिकतम मिलान सेट नहीं हैं, लेकिन नीले रंग के नीचे के दोनों सेट अधिकतम मिलान वाले हैं। ध्यान दें कि अधिकतम मिलान आवश्यक रूप से अद्वितीय नहीं हैं। इसके अलावा, कोई आवश्यकता नहीं है कि ग्राफ़ के लिए प्रत्येक संभावित अधिकतम मिलान का आकार किसी अन्य मिलान के बराबर है।

इस चुनौती का लक्ष्य एक ग्राफ के अधिकतम मिलान को खोजने के लिए एक कार्यक्रम / फ़ंक्शन लिखना है।

इनपुट

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

[(0,1), (0,2), (1,3), (1,4), (2,3), (3,4), (3,5), (5,6)]

एक ग्राफ का वर्णन करने का एक वैकल्पिक तरीका एक आसन्न सूची के माध्यम से है। यहाँ उपरोक्त ग्राफ के लिए एक उदाहरण आसन्न सूची है:

[0:(1,2), 1:(0,3,4), 2:(0,3), 3:(1,2,4,5), 4:(1,3), 5:(3,6), 6:(5)]

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

आप मान सकते हैं:

1. ग्राफ जुड़ा हुआ है (उदाहरण के लिए किसी भी शुरुआती शीर्ष दिए गए किसी भी शीर्ष तक पहुंचना संभव है)।
2. कम से कम एक किनारे है।
3. एक किनारा कभी भी एक शीर्ष को सीधे अपने आप से जोड़ता नहीं है (उदाहरण के लिए बढ़त (1,1)इनपुट के रूप में नहीं दी जाएगी)। ध्यान दें कि चक्र अभी भी संभव है (उदाहरण: उपरोक्त रेखांकन)।
4. आपको आवश्यकता हो सकती है कि इनपुट कोने किसी भी इंडेक्स पर शुरू हों (उदाहरण के पहले शीर्ष 0, 1, -1, आदि हो सकते हैं)।
5. वर्टेक्स नंबरिंग आपके चुने हुए शुरुआती इंडेक्स (उदा .: 1,2,3,4,..., या 0,1,2,3,...) से क्रमिक रूप से बढ़ रही है ।

उत्पादन

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

[(1,4), (2,3), (5,6)]

ध्यान दें कि कोने का क्रम महत्वपूर्ण नहीं है; तो निम्न आउटपुट एक ही मिलान सेट का वर्णन करता है:

[(4,1), (2,3), (6,5)]   

आउटपुट स्टडआउट, एक फ़ाइल, फ़ंक्शन रिटर्न मान आदि हो सकता है।

उदाहरण

यहां कुछ उदाहरण इनपुट दिए गए हैं (आसन्न सूची प्रारूप का उपयोग करके)। इन उदाहरणों में उल्टी गिनती शुरू करने के लिए होता है 0।

ध्यान दें कि कोई उदाहरण आउटपुट नहीं दिया जाता है, इसके बजाय मैंने पायथन 3 सत्यापन कोड शामिल किया है।

[0:(1), 1:(0)]

[0:(1,2), 1:(0,3,4), 2:(0,3), 3:(1,2,4,5), 4:(1,3), 5:(3,6), 6:(5)]

[0:(1,2), 1:(0,2,3,4,5), 2:(0,1), 3:(1), 4:(1), 5:(1)]

[0:(1,2), 1:(0,2,3), 2:(0,1,4), 3:(1,4,5), 4:(2,3), 5:(3)]

मान्यता पायथन 3 कोड

यहाँ एक पायथन 3 सत्यापन कोड है जो एक ग्राफ़ में सेट होता है और किनारों और प्रिंटों का सेट करता है और यह निर्धारित करता है कि यह सेट अधिकतम मेल खाता है या नहीं। यह कोड किसी भी शीर्ष स्टार्ट इंडेक्स के साथ काम करता है।

def is_maximal_matching(graph, edges):
    '''
    Determines if the given set of edges is a maximal matching of graph
    @param graph a graph specified in adjacency list format
    @param edges a list of edges specified as vertex pairs

    @return True if edges describes a maximal matching, False otherwise.
    Prints out some diagnostic text for why edges is not a maximal matching
    '''

    graph_vtxs = {k for k,v in graph.items()}
    vtxs = {k for k,v in graph.items()}

    # check that all vertices are valid and not used multiple times
    for e in edges:
        if(e[0] in graph_vtxs):
            if(e[0] in vtxs):
                vtxs.remove(e[0])
            else:
                print('edge (%d,%d): vertex %d is used by another edge'%(e[0],e[1],e[0]))
                return False
        else:
            print('edge (%d,%d): vertex %d is not in the graph'%(e[0],e[1],e[0]))
            return False
        if(e[1] in graph_vtxs):
            if(e[1] in vtxs):
                vtxs.remove(e[1])
            else:
                print('edge (%d,%d): vertex %d is used by another edge'%(e[0],e[1],e[1]))
                return False
        else:
            print('edge (%d,%d): vertex %d is not in the graph'%(e[0],e[1],e[0]))
            return False
        if(e[1] not in graph[e[0]]):
            print('edge (%d,%d): edge not in graph'%(e[0],e[1]))
            return False

    # check that any edges can't be added
    for v in vtxs:
        ovtxs = graph[v]
        for ov in ovtxs:
            if(ov in vtxs):
                print('could add edge (%d,%d) to maximal set'%(v,ov))
                return False

    return True

उदाहरण का उपयोग:

graph = {0:[1,2], 1:[0,3,4], 2:[0,3], 3:[1,2,4,5], 4:[1,3], 5:[3,6], 6:[5]}
candidate = [(0,1),(2,3)]
is_maximal_matching(graph, candidate) // False
candidate = [(0,1),(2,3),(5,6),(0,1)]
is_maximal_matching(graph, candidate) // False
candidate = [(0,1),(2,3),(5,6)]
is_maximal_matching(graph, candidate) // True

स्कोरिंग

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

Answer 1

CJam (16 वर्ण)

{M\{_2$&!*+}/2/}

ऑनलाइन डेमो

यह एक लालची दृष्टिकोण है जो किनारों को जमा करता है जिसमें पहले संचित किनारों के साथ आम तौर पर कोई शीर्ष नहीं होता है।

Comments

मुझे पूरा यकीन है कि यह [[0 1] [3 4]]मैक्सिमम सेट के बजाय तीसरे उदाहरण पर विफल होता है [[0 2] [1 4] [3 5]]। (मैं उस (1, 1)किनारे की अनदेखी कर रहा हूं जो गलती से वहां लगता है)

— ETHproductions

@ETHproductions, आप अधिकतम के साथ अधिकतम भ्रमित कर रहे हैं।

— पीटर टेलर

इस बारे में खेद, खेद है ... मैं अपनी टिप्पणी किसी भी अन्य व्यक्ति की मदद करने के लिए छोड़ दूंगा, जो भ्रमित हैं, अगर आपको कोई आपत्ति नहीं है, क्योंकि यह एक आवर्ती मुद्दा लगता है :-P

— ETHproductions

Answer 2

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

ef{IsTty
       y  power set (gerenate all set of edges)
      t   remove the first one (the first one is
          empty and will cause problems)
 f        filter for sets T satisfying:
     T        T
    s         flatten
  {I          is invariant under deduplicate, i.e. contains no
              duplicating vertices, as the elements represent vertices
e         pick the last one (the power set is ordered from
          smallest to largest)

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

ऐनक

• इनपुट: [(0,1), (0,2), (1,3), (1,4), (2,3), (3,4), (3,5), (5,6)]
• आउटपुट: [(1, 4), (2, 3), (5, 6)]

Answer 3

वोल्फ्राम भाषा, 25 22 बाइट्स

@MartinEnder की बदौलत 3 बाइट्स बचाए

FindIndependentEdgeSet

यह एक Graphवस्तु के रूप में इनपुट लेता है ( Graph[{1<->2,2<->3,1<-3>}]आदि के रूप में परिभाषित )

Comments

आप की जरूरत नहीं है @#&।

— मार्टिन एंडर

@MartinEnder धन्यवाद

— स्कॉट मिलनर

Pfft। import solve_problem; run()। अब किसी को सिर्फ वुल्फ्राम के लिए एक प्लगइन लिखने की ज़रूरत है जो एक कोडगॉल्फ चैलेंज URL में लेता है और वांछित आउटपुट देता है। इसे बुलाओ Golf।

— Draco18s अब SE

Answer 4

ब्रेकीलॉग , 5 बाइट्स

 ⊇.c≠∧

?⊇.cL≠   implicit ? at the beginning;
         ∧ breaks implicit . at the end;
         temporary variable inserted.
?⊇.      input is a superset of output
  .cL    output concatenated is L
    L≠   L contains distinct elements

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

यह अधिकतम होने की गारंटी है, क्योंकि ब्रेकीलॉग सबसे बड़े सबसेट से खोज करता है।

Comments

मुझे लगता है कि आपके स्पष्टीकरण में आपके वास्तविक कोड की तुलना में अलग कोड है।

— आउटगॉल्फ

@EriktheOutgolfer ऐसा इसलिए है क्योंकि मैंने अपने स्पष्टीकरण में निहित पात्रों को सम्मिलित किया है। मूल कोड पहली पंक्ति में है। इस पहलू में ब्रैकलॉग काफी चर्चित है।

— लीक नून

मेरा मतलब यह नहीं है, लेकिन पहला कोड समाप्त होता है ≠∧, जबकि दूसरा कोड समाप्त होता है L≠।

— आउटगोल्फर

इसके बिना ∧, .अंत में एक निहितार्थ होगा । ∧यहाँ सभी का अर्थ है कि .अंत में सम्मिलित नहीं होना है।

— लीक नून

Lएक अस्थायी चर कि कहीं प्रयोग किया जाता है इसलिए इसकी क्षमता लोप हो रहा है,।

— लीक नून

Answer 5

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

let f =
a=>a.map(b=>r.some(c=>c.some(d=>~b.indexOf(d)))||r.push(b),r=[])&&r

let g = a => console.log("[%s]", f(a).map(x => "[" + x + "]").join(", "))
g([[0,1]])
g([[0,1], [0,2], [1,3], [1,4], [2,3], [3,4], [3,5], [5,6]])
g([[0,1], [0,2], [1,2], [1,3], [1,4], [1,5]])
g([[0,1], [0,2], [1,2], [1,3], [2,4], [3,4], [3,5]])

अधिकतम गोल्फ के लिए लालची दृष्टिकोण का उपयोग करता है।

Answer 6

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

f=a=>a[0]?[a[0],...f(a.filter(b=>!a[0].some(c=>~b.indexOf(c))))]:a
f=([b,...a])=>b?[b,...f(a.filter(c=>!c.some(c=>~b.indexOf(c))))]:a

मैंने सोचा था कि मैं पुनरावर्ती दृष्टिकोण को जाने दूंगा, और @ ETHproduction के सेट चौराहे की चोरी से मैं उनके जवाब को कम करने में कामयाब रहा!

मैं मूल प्रश्न को गलत बताने वाला पहला व्यक्ति नहीं था, और मैं निम्नलिखित पुनरावर्ती फ़ंक्शन को प्रस्तुत करने वाला था जो कि मिलान किनारों के एक सेट के बजाय मिलान किनारों का एक अधिकतम सेट पाता है। सूक्ष्म अंतर, मुझे पता है!

f=a=>a.map(([b,c])=>[[b,c],...f(a.filter(([d,e])=>b-d&&b-e&&c-d&&c-e))]).sort((d,e)=>e.length-d.length)[0]||[]

सरल पुनरावर्ती दृष्टिकोण। प्रत्येक इनपुट तत्व के लिए, सेट से सभी परस्पर विरोधी किनारों को हटाता है और शेष उपसमूह के मिलान किनारों का अधिकतम सेट पाता है, फिर प्रत्येक इनपुट तत्व पर अधिकतम परिणाम पाता है। बड़े सेटों के लिए कुछ हद तक अक्षम (9-बाइट स्पीड-अप संभव)।

Answer 7

जेली , 12 11 बाइट्स

FQ⁼F
ŒPÇÐfṪ

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

नमूना इनपुट: [0,1],[0,2],[1,3],[1,4],[2,3],[3,4],[3,5],[5,6]

नमूना उत्पादन: [[1, 4], [2, 3], [5, 6]]

यह काम किस प्रकार करता है

FQ⁼F    - Helper function, returns 1 if a set of edges is non-matching
F       - Flatten input
 Q      - Remove repeated elements
  ⁼     - Return boolean value. Is this equal to
   F    - The flattened input list

ŒPÇÐfṪ - Main link.
ŒP     - Power set of input list of edges
   Ðf  - Remove all elements which return 1 if
  Ç    - (Helper function) it is a non-matching set
     Ṫ - Get the last element in the resultant list (the longest). 
           Always maximal because it is the longest, so any
           edge added would not be in this list (not matching)