Etiketsiz ağaçların verimli sıkıştırılması

Etiketlenmemiş, köklü ikili ağaçları düşünün. Biz olabilir sıkıştırmak alt ağaç işaretçileri vardır zaman: bu ağaçlar ve ile (yorumlama yapısal eşitlik) aksine, depolamak (wlog) ve tüm işaretçiler yerine işaretçilerle . Örnek için uli'nin cevabına bakınız .$T$$T'$$T = T'$$=$$T$$T'$$T$

Yukarıdaki anlamda bir ağacı girdi olarak alan ve sıkıştırmadan sonra kalan (minimum) düğüm sayısını hesaplayan bir algoritma verin. Algoritma zaman çalışmalıdır ile (tek bir maliyet modelinde) giriş düğüm sayısına.$\cal{O}(n\log n)$$n$

Bu bir sınav sorusuydu ve ne güzel bir çözüm bulamadım ne de bir çözüm bulamadım.

Evet, bu sıkıştırmayı zamanında yapabilirsiniz, ancak bu kolay değildir :) Önce bazı gözlemler yaparız ve sonra algoritmayı sunarız. Ağacın başlangıçta sıkıştırılmadığını varsayarız - bu gerçekten gerekli değildir, ancak analizi kolaylaştırır.$O(n \log n)$

İlk olarak, 'yapısal eşitliği' tümevarımsal olarak nitelendiriyoruz. Let ve T ' , iki (alt) ağaç olabilir. Eğer T ve T ' (da hiç tepe noktalarına sahip olan) boş ağaç hem de, yapısal eşdeğerdir. Eğer T ve T ' hem boş değil ağaçlar, bu durumda onlar da sol çocukları yapısal olarak eşdeğerdir ve onların sağ çocukları yapısal olarak eşdeğerdir IFF yapısal olarak eşdeğerdir. 'Yapısal eşdeğerlik', bu tanımlar üzerindeki minimum sabit noktadır.$T$$T'$$T$$T'$$T$$T'$

Örneğin, herhangi iki yaprak düğümü yapısal olarak eşdeğerdir, çünkü her ikisi de yapısal olarak eşdeğer olan her iki çocuğu olarak da boş ağaçlara sahiptir.

'Sol çocukları yapısal olarak eşdeğerdir ve sağ çocukları da' demek oldukça can sıkıcı olduğu için, sık sık 'çocukları yapısal olarak eşdeğerdir' diyeceğiz ve aynı şeyi düşüneceğiz. Ayrıca, 'bu tepe noktasına dayanan alt ağaç' demek istediğimizde bazen 'bu tepe noktasını' söylediğimizi unutmayın.

Yukarıdaki tanım bize derhal sıkıştırmanın nasıl yapılacağına dair bir ipucu verir: tüm alt ağaçların derinliği en fazla olan yapısal eşdeğerliğini bilirsek, alt ağaçların yapısal eşdeğerliğini d + 1 derinliği ile kolayca hesaplayabiliriz . O ( n 2 ) çalışma süresinden kaçınmak için bu hesaplamayı akıllı bir şekilde yapmak zorundayız .$d$$d+1$$O(n^2)$

Algoritma, yürütülmesi sırasında her tepe noktasına tanımlayıcılar atayacaktır. Bir tanımlayıcı kümesindeki bir sayıdır . Tanımlayıcılar benzersizdir ve asla değişmez: bu nedenle algoritmanın başlangıcında bazı (global) değişkenleri 1 olarak ayarladığımızı ve bazı tepe noktalarına her tanımlayıcı atadığımızda, bu değişkenin geçerli değerini tepe noktasına ve artışa atarız bu değişkenin değeri.$\{ 1, 2, 3, \dots, n \}$

İlk olarak giriş ağacını , ebeveynlerine bir işaretçi ile birlikte eşit derinliğe sahip köşeler içeren (en fazla ) listeye dönüştürüyoruz . Bu kolayca O ( n ) zamanda yapılabilir.$n$$O(n)$

Öncelikle tüm yaprakları (bu yaprakları listede 0 derinlik köşeleriyle bulabiliriz) tek bir tepe noktasına sıkıştırırız. Bu tepe noktasına bir tanımlayıcı atarız. İki köşenin sıkıştırılması, her bir tepe noktasının üst öğesini diğer tepe noktasına işaret edecek şekilde yönlendirerek yapılır.

İki gözlem yapıyoruz: ilk olarak, herhangi bir tepe noktasının kesinlikle daha küçük derinliğe sahip çocukları var ve ikincisi, den daha küçük tüm derinliklerde sıkıştırma gerçekleştirdiysek (ve onlara tanımlayıcılar verdiysek ), d derinliğinin iki köşesi yapısal olarak eşdeğerdir ve çocuklarının tanımlayıcıları çakıştığında sıkıştırılabilir. Bu son gözlem aşağıdaki argümandan kaynaklanmaktadır: iki köşesi, çocukları yapısal olarak eşdeğer olduğunda yapısal olarak eşdeğerdir ve sıkıştırmadan sonra, işaretçileri aynı çocukları işaret ettiği anlamına gelir, bu da çocuklarının tanımlayıcılarının eşit olduğu anlamına gelir.$d$$d$

Küçük derinlikten büyük derinliğe kadar eşit derinliğe sahip düğümleri olan tüm listeleri tekrarlıyoruz. Her seviye için, her bir çiftin o seviyedeki bazı tepe noktalarının çocuklarının tanımlayıcılarına karşılık geldiği bir tamsayı çiftleri listesi oluştururuz. Karşılık gelen tamsayı çiftleri eşit olduğu takdirde, bu seviyedeki iki köşenin yapısal olarak eşdeğer olduğuna sahibiz. Sözcük bilgisi düzenini kullanarak bunları sıralayabilir ve eşit olan tamsayı çiftleri kümesini elde edebiliriz. Bu setleri yukarıdaki gibi tek köşelere sıkıştırır ve tanımlayıcıları veririz.

Yukarıdaki gözlemler bu yaklaşımın işe yaradığını ve sıkıştırılmış ağaçla sonuçlandığını kanıtlamaktadır. Toplam çalışma süresi artı oluşturduğumuz listeleri sıralamak için gereken süredir. Oluşturduğumuz tamsayı çiftlerinin toplam sayısı n olduğundan bu, toplam çalışma süresinin gerektiği gibi O ( n log n ) olduğunu gösterir. Prosedürün sonunda kaç düğüm kaldığımızı saymak önemsizdir (sadece kaç tanımlayıcıyı dağıttığımıza bakın).$O(n)$$n$$O(n \log n)$

Değişken olmayan bir veri yapısının, yapısal olarak eşit herhangi bir arayı kopyalamaması için sıkıştırılması, karma eksing olarak bilinir . Bu fonksiyonel programlamada bellek yönetiminde önemli bir tekniktir. Hash consing, veri yapıları için bir tür sistematik nottur.

Ağacı hash-cons olarak yapacağız ve hash consing'den sonra düğümleri sayacağız. boyutunda bir veri yapısına sahip olan karma her zaman O ( n) olarak yapılabilir$n$ işlemleri; sondaki düğüm sayısının sayılması, düğüm sayısında doğrusaldır.$O(n\:\mathrm{lg}(n))$

Ağaçları aşağıdaki yapıya sahip olarak değerlendireceğim (burada Haskell sözdiziminde yazılmıştır):

data Tree = Leaf
          | Node Tree Tree

Her kurucu için, kurucuyu bu argümanlara uygulama sonucuna kadar olası argümanlarından bir eşleme yapmamız gerekir. Yapraklar önemsizdir. Düğüm için, sınırlı bir kısmi haritasını sağlamak , T ağaç tanımlayıcıları grubu olup , N düğümü tanımlayıcıları grubu olduğu; T = N ⊎ { ℓ } burada ℓ tek yaprak tanımlayıcıdır. (Somut olarak, tanımlayıcı bir bellek bloğunun göstergesidir.)$\mathtt{nodes} : T \times T \to N$$T$$N$$T = N \uplus \{\ell\}$$\ell$

nodesDengeli bir ikili arama ağacı gibi logaritmik-zaman veri yapısını kullanabiliriz . Aşağıda veri yapısında lookup nodesbir anahtarı arayan işlemi ve yeni bir anahtarın altına bir değer ekleyen ve bu anahtarı döndüren işlemi çağıracağım .nodesinsert nodes

Şimdi ağacı hareket ettiriyoruz ve ilerledikçe düğümleri ekliyoruz. Her ne kadar Haskell benzeri sözde kod yazsam da, nodesküresel değişken bir değişken olarak ele alacağım ; buna yalnızca ekleyeceğiz, ancak eklemelerin her tarafa geçirilmesi gerekiyor. addFonksiyon olan alt ağaçlar ekleyerek, ağaç recurses nodesharita ve kök tanıtıcısı döndürür.

insert (p1,p2) =
add Leaf = $\ell$
add (Node t1 t2) =
    let p1 = add t1
    let p2 = add t2
    case lookup nodes (p1,p2) of
      Nothing -> insert nodes (p1,p2)
      Just p -> p

Aynı insertzamanda nodesveri yapısının son boyutu olan çağrı sayısı, maksimum sıkıştırmadan sonraki düğüm sayısıdır. (Gerekirse boş ağaç için bir tane ekleyin.)

İşte ağaçların yapısını keyfi olarak etiketlemek yerine (enjekte ederek) sayılara kodlamayı amaçlayan başka bir fikir. Bunun için herhangi bir sayının asal çarpanlaştırmasının benzersiz olduğunu kullanıyoruz.

Bizim amacımız için, ağaçta boş bir konumu ve N ( l , r ) sol alt ağaç l ve sağ alt ağaç r olan bir düğümü belirtmesine izin verin . N ( E , E ) bir yaprak olurdu. Şimdi izin ver$E$$N(l,r)$$l$$r$$N(E,E)$

$\qquad \displaystyle \begin{align*} f(E) &= 0 \\ f(N(l,r)) &= 2^{f(l)}\cdot 3^{f(r)} \end{align*}$

kullanarak , bir ağaç altta bulunan tüm alt ağaçların kümesini hesaplayabiliriz; her düğümde, çocuklardan elde edilen kodlama kümelerini birleştirir ve yeni bir sayı ekleriz (bu, çocukların kodlamalarından sabit zamanda hesaplanabilir).$f$

Bu son varsayım gerçek makinelerde bir gerginliktir; bu durumda, üstel olmak yerine Cantor'un eşleştirme işlevine benzer bir şey kullanmayı tercih ederim .

Bu algoritmanın çalışma zamanı ağacın yapısına bağlıdır (dengeli ağaçlarda, doğrusal zamanda birleşmeye izin veren herhangi bir uygulama ile). Genel ağaçlar için, basit bir analizle logaritmik zaman birliğine ihtiyacımız olurdu. Belki de karmaşık bir analiz yardımcı olabilir; her zamanki en kötü durum ağacı olan doğrusal listenin burada O ( n log n ) zamanını kabul ettiğine dikkat edin , bu yüzden en kötü durumun ne olduğu çok açık değildir.$\cal{O}(n \log n)$$\cal{O}(n \log n)$

Yorumlarda resimlere izin verilmediği için:

sol üst: giriş ağacı

sağ üst: düğüm 5 ve 7'de köklenen alt ağaçlar da izomorfiktir.

sol alt ve sağ: sıkıştırılmış ağaçlar benzersiz bir şekilde tanımlanmamıştır.

$7+5|T|$$6+|T|$

Düzenleme: T ve T same aynı ebeveynin çocukları olarak soruyu okudum. Sıkıştırma tanımını da özyinelemeli olarak aldım, yani önceden sıkıştırılmış iki alt ağacı sıkıştırabilirsiniz. Asıl soru bu değilse, cevabım işe yaramayabilir.

$O(n \log n)$ için yalvarır $T(n) = 2T(n/2) + cn$böl ve çöz çözümü. Düğümleri yinelemeli olarak sıkıştırın ve sıkıştırmadan sonra her alt ağaçtaki torun sayısını hesaplayın. İşte bazı python-esque sözde kodu.

def Comp(T):
   if T == null:
     return 0
   leftCount = Comp(T.left)
   rightCount = Comp(T.right)
   if leftCount == rightCount:
     if hasSameStructure(T.left, T.right):
       T.right = T.left
       return leftCount + 1
     else
       return leftCount + rightCount + 1    

hasSameStructure()Aynı yapıya sahip olup olmadıklarını görmek için önceden sıkıştırılmış iki alt çizgiyi doğrusal zamanda karşılaştıran bir işlev nerede . Herbiri gezen ve diğerinin her yaptığında bir alt ağacın sol çocuğu olup olmadığını kontrol eden doğrusal zaman özyinelemeli bir işlev yazmak zor olmamalıdır.

İzin Vermek $n_\ell$ ve $n_r$sırasıyla sol ve sağ alt ağaçların boyutları (sıkıştırmadan sonra) olmalıdır. Sonra çalışma süresi