Bağlı yönlendirilmemiş bir grafik düşünün. Bir kenarların eşleşen bir dizi bu grafikte kenarlar öyle ki grubu payında iki kenar ortak bir tepe oluşan bir dizi olarak tanımlanmıştır. Örneğin, soldaki şekil yeşil ile eşleşen bir kümeyi belirtirken, sağdaki şekil kırmızı ile eşleşen olmayan bir kümeyi belirtir.

Eşleşen bir kümenin maximally matchingveya maximal matchinga'nın eşleşen kümeye grafiğin başka bir kenarını eklenmesi mümkün değilse denir. Bu nedenle, yukarıdaki her iki örnek de en fazla eşleşen kümeler değildir, ancak aşağıdaki mavi kümelerin her ikisi de maksimum eşleşmelerdir. Maksimum eşleşmelerin mutlaka benzersiz olmadığını unutmayın. Ayrıca, bir grafik için her olası maksimum eşleşmenin boyutunun başka bir eşleşmeye eşit olması gerekmez.

Bu zorluğun amacı, bir grafiğin maksimum eşleşmesini bulmak için bir program / işlev yazmaktır.

Giriş

Girdi grafiğinin tüm köşelerinde, seçtiğiniz herhangi bir başlangıç ​​tamsayı değerinden başlayarak ardışık bir tamsayı numaralandırması olduğunu varsayın. Bir kenar, kenarın bağlandığı köşeleri belirten sıralanmamış bir tamsayı çifti tarafından tanımlanır. Örneğin, yukarıda gösterilen grafik aşağıdaki sıralanmamış kenar kümesiyle açıklanabilir (köşe numaralarının numaralandırılmasının 0 ile başladığı varsayılarak):

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

Grafiği tanımlamanın alternatif bir yolu bir bitişiklik listesidir. Yukarıdaki grafik için örnek bir bitişiklik listesi:

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

Programınız / fonksiyonunuz herhangi bir kaynaktan (stdio, fonksiyon parametresi, vb.) Girdi olarak bir grafik almalıdır. Önemsiz hiçbir ek bilgi programınıza iletilmediği sürece istediğiniz gösterimi kullanabilirsiniz. Örneğin, giriş kenarlarının sayısını belirten fazladan bir parametreye sahip olmak tamamen kabul edilebilir. Benzer şekilde, kenarların, bitişiklik listesinin veya bitişiklik matrisinin düzensiz bir çoklu kümesinden geçmek iyidir.

Varsayabilirsiniz:

1. Grafik bağlanmıştır (örn. Başlangıç ​​köşesi verilen herhangi bir tepe noktasına ulaşmak mümkündür).
2. En az bir kenar var.
3. Kenar hiçbir zaman bir tepe noktasını doğrudan kendisine bağlamaz (örn. Kenar (1,1)giriş olarak verilmez). Döngülerin hala mümkün olduğunu unutmayın (örn. Yukarıdaki grafikler).
4. Giriş köşelerinin herhangi bir dizinden başlamasını isteyebilirsiniz (örneğin, ilk tepe noktası 0, 1, -1 vb. Olabilir).
5. Tepe noktası numaralandırması, seçtiğiniz başlangıç ​​dizininden (ör .: 1,2,3,4,...veya 0,1,2,3,...) art arda artmaktadır .

Çıktı

Programınız / işleviniz, maksimum eşleme kümesini gösteren kenarların bir listesini çıkarmalıdır. Bir kenar, o kenarın bağlandığı iki köşe tarafından tanımlanır. Ör. sol mavi küme çıkışı (örnek girdi tepe noktası sıralaması kullanılarak):

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

Köşelerin sırasının önemli olmadığını unutmayın; Dolayısıyla, aşağıdaki çıktıda aynı eşleşen küme açıklanmaktadır:

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

Çıktı stdout, dosya, işlev dönüş değeri vb. Olabilir.

Örnekler

İşte birkaç örnek giriş (bitişik liste biçimini kullanarak). Bu örnekler adresindeki köşeleri saymaya başlar 0.

Örnek çıktılar verilmediğini unutmayın, bunun yerine bir Python 3 doğrulama kodu ekledim.

[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)]

Doğrulama Python 3 kodu

İşte bir grafik ve kenar kümesini alan ve bu kümenin maksimum eşleşip eşleşmediğini yazdıran bir Python 3 doğrulama kodu. Bu kod, herhangi bir tepe başlangıç ​​diziniyle çalışır.

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

Örnek kullanım:

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

puanlama

Bu kod golf; en kısa kod kazanır. Standart boşluklar geçerlidir. İstediğiniz yerleşik bileşenleri kullanabilirsiniz.

CJam (16 karakter)

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

Çevrimiçi demo

Bu, daha önce biriken kenarlarla ortak bir tepe noktası olmayan kenarları biriktiren açgözlü bir yaklaşımdır.

Pyth , 8 bayt

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)

Çevrimiçi deneyin!

gözlük

• Giriş: [(0,1), (0,2), (1,3), (1,4), (2,3), (3,4), (3,5), (5,6)]
• Çıktı: [(1, 4), (2, 3), (5, 6)]

Wolfram Dili, 25 22 bayt

@MartinEnder sayesinde 3 bayt kaydedildi

FindIndependentEdgeSet

Bu, girdiyi Graphnesne olarak alır ( Graph[{1<->2,2<->3,1<-3>}]vb. Olarak tanımlanır )

Brachylog , 5 bayt

 ⊇.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

Çevrimiçi deneyin!

Brachylog en büyük alt kümeden arama yaptığından, bunun maksimum olması garanti edilir.

JavaScript (ES6), 67 bayt

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]])

Maksimum golf için açgözlü yaklaşımı kullanır.

JavaScript (ES6), 68 66 bayt

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

Özyinelemeli yaklaşıma bir şans vereceğimi düşündüm ve @ ETHproduction'ın kesişim hilesini çalarak cevabını altüst etmeyi başardım!

Orijinal soruyu yanlış okuyan ilk kişi ben değildim ve maksimum eşleşen kenarlar kümesi yerine, eşleşen kenarların maksimum kümesini bulan aşağıdaki özyinelemeli işlevi göndermek üzereydim. İnce fark, biliyorum!

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]||[]

Basit özyinelemeli yaklaşım. Her girdi öğesi için, kümeden çakışan tüm kenarları siler ve kalan alt kümenin en fazla eşleşen kenar kümesini bulur, ardından her girdi öğesi üzerinde en yüksek sonucu bulur. Büyük setler için biraz verimsiz (9 bayt hızlanma mümkündür).

Jöle , 12 11 bayt

FQ⁼F
ŒPÇÐfṪ

Çevrimiçi deneyin!

Örnek giriş: [0,1],[0,2],[1,3],[1,4],[2,3],[3,4],[3,5],[5,6]

Örnek çıktı: [[1, 4], [2, 3], [5, 6]]

Nasıl çalışır

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)