Açgözlü algoritma kanıtlamak nasıl doğru

Doğru olabileceğinden şüphelendiğim açgözlü bir algoritma var ama emin değilim. Doğru olup olmadığını nasıl kontrol edebilirim? Açgözlü bir algoritmayı doğrulamak için kullanılacak teknikler nelerdir? Ortak kalıplar veya teknikler var mı?

^{Bunun yeni başlayanlara işaret etmek için kullanılabilecek bir referans sorusu olacağını umuyorum ; dolayısıyla normalden daha geniş kapsamı. Lütfen en az bir örnekle gösterilen, ancak yine de birçok durumu kapsayan genel, didaktik olarak sunulan cevaplar vermeye özen gösterin. Teşekkürler!}

Sonuçta, matematiksel bir doğruluk kanıtına ihtiyacınız olacak. Aşağıda bunun için bazı kanıt tekniklerini kullanacağım, ama önce, buna dalmadan önce, size biraz zaman kazandıracağım: bir kanıt aramadan önce rastgele test yapmayı deneyin.

Rastgele test

İlk adım olarak, algoritmanızı test etmek için rastgele testler kullanmanızı öneririm. Bunun ne kadar etkili olduğu şaşırtıcı: benim açımdan, açgözlü algoritmalar için rastgele testlerin makul derecede etkili olduğu görülüyor. Algoritmanızı kodlamak için 5 dakika harcayın ve bir kanıt bulmaya çalışırken kendinizi bir ya da iki saatten tasarruf edebilirsiniz.

Temel fikir basit: algoritmanızı uygulayın. Ayrıca, doğru olduğunu bildiğiniz bir referans algoritması uygulayın (örneğin, tüm olasılıkları ayrıntılı olarak deneyen ve en iyisini alan bir algoritma). Referans algoritmanızın asimptotik olarak verimsiz olması sorun değil, çünkü bunu sadece küçük problem örneklerinde çalıştırabilirsiniz. Ardından, rastgele bir milyon küçük sorun örneği oluşturun, her iki algoritmayı da çalıştırın ve aday algoritmanızın her durumda doğru cevabı verip vermediğini kontrol edin.

Ampirik olarak, eğer aday açgözlü algoritmanız yanlışsa, genellikle bunu rastgele testler sırasında keşfedeceksiniz. Tüm test durumlarında doğru gibi görünüyorsa, bir sonraki adıma geçmelisiniz: Matematiksel bir doğruluk kanıtı ile gelmek.

Matematiksel doğruluk kanıtları

Tamam, bu nedenle açgözlü algoritmamızın doğru olduğunu ispatlamamız gerekiyor: en uygun çözümü ürettiğini (ya da eşit derecede iyi olan birden fazla optimal çözüm varsa, bunlardan birini çıkardığını).

Temel ilke sezgiseldir:

Prensip: Asla kötü bir seçim yapmazsan, tamam diyeceksin.

Açgözlü algoritmalar genellikle bir dizi seçeneği içerir. Temel kanıt stratejisi, algoritmanın asla kötü bir seçim yapmadığını kanıtlamaya çalışacağımızdır. Açgözlü algoritmalar geri adım atamaz - bir seçim yaptıklarında, kararlıdırlar ve bu seçimi geri almazlar - bu yüzden asla kötü bir seçim yapmamaları çok önemlidir.

İyi bir seçenek olarak ne sayılır? Tek bir optimal çözüm varsa, neyin iyi bir seçim olduğunu görmek kolaydır: optimum çözüm tarafından yapılan ile aynı olan herhangi bir seçenek. Başka bir deyişle, açgözlü algoritmaların yürütülmesinin herhangi bir aşamasında, algoritma tarafından yapılan seçeneklerin sırasının, optimal çözümün bazı önekleriyle tam olarak eşleştiğini kanıtlamaya çalışacağız. Birden fazla eşit derecede iyi en iyi çözüm varsa, iyi bir seçim, en az bir tane ile en uygun olanıdır. Başka bir deyişle, algoritmanın şu ana kadarki tercih dizisi, en uygun çözümlerden birinin önekiyle eşleşirse, şu ana kadar her şey yolundadır (henüz hiçbir şey ters gitmedi).

Hayatı basitleştirmek ve dikkat dağıtıcı şeyleri ortadan kaldırmak için, bağın olmadığı duruma odaklanalım: tek ve benzersiz bir optimum çözüm var. Tüm makineler, temelde herhangi bir değişiklik olmadan aynı anda çok iyi optima olabileceği duruma gelecektir, ancak teknik detaylar konusunda biraz daha dikkatli olmalısınız. Bu ayrıntıları yok sayarak ve en uygun çözümün benzersiz olduğu duruma odaklanarak başlayın; Bu neyin gerekli olduğuna odaklanmanıza yardımcı olacaktır.

Kullandığımız çok yaygın bir kanıt deseni var. Algoritmanın aşağıdaki özelliğini ispatlamak için çok çalışacağız:

İddia: Let algoritması ile çözelti çıkışı ve uygun çözüm. Eğer farklıdır , o zaman çimdik başka bir çözüm elde etmek farklıdır ve kesinlikle daha iyi .O S O O O * O $S$$O$$S$$O$$O$$O^*$$O$$O$

Bunun neden faydalı olduğuna dikkat edin. Eğer iddia doğru ise, algoritmanın doğru olduğunu izler. Bu temelde çelişki ile bir kanıtıdır. Her iki aynıdır ya da farklıdır. Farklı ise, o zaman başka bir çözüm bulabilirsiniz kesinlikle daha iyi olduğunu - ama biz tanımlandığı gibi olduğu, bir çelişki optimal çözüm olmak ve bundan daha var herhangi bir çözüm olamaz. Bu yüzden farklı olamayacağı sonucuna vardık ; her zaman eşit olmalıÇ Ç * Ç Ç S O S $S$$O$$O^*$$O$$O$$S$$O$$S$$O$yani açgözlü algoritma her zaman doğru çözümü ortaya çıkarır. Yukarıdaki iddiayı ispatlayabilirsek, algoritmamızı doğru kanıtladık.

İnce. Öyleyse iddiayı nasıl kanıtlarız? çözümünü , algoritma tarafından yapılan seçim sırasına karşılık gelen bir vektör düşünüyoruz ve benzer şekilde, bir vektör olarak en uygun çözümünü yol açacak seçeneklerin sırasına karşılık gelir . Eğer , farklıysa, indeksi var olmalıdır ; burada ; Biz en küçük Böyle odaklanacağız . Sonra, çimdik edeceğiz değiştirerek içinde biraz( S 1 , ... , S , n ) n, O ( O 1 , ... , O , n ) O S O i S i ≠ O i i O O i S i O i O $S$$(S_1,\dots,S_n)$$n$$O$$(O_1,\dots,O_n)$$O$$S$$O$$i$$S_i \ne O_i$$i$$O$$O$$i$inci pozisyon maç için , yani biz optimal çözüm çimdik edeceğiz değiştirerek açgözlü algoritma tarafından seçilen birine inci seçim, sonra göstereceğiz ki daha yüksek çözüme bu yol açar. Özellikle, gibi bir şey tanımlayacağız$S_i$$O$$i$$O^*$

bunun dışında, genel tutarlılığı korumak için bölümünü hafifçe değiştirmeniz gerekecektir. Kanıtlama stratejisinin bir kısmı, uygun şekilde tanımlanmasında bir miktar zekâ içerir . O zaman, ispatın eti bir şekilde algoritma hakkındaki gerçekleri ve kesinlikle daha iyi olduğunu gösterme problemini kullanıyor olacak ; Probleme özgü bazı görüşlere ihtiyacınız olacak yer burasıdır. Bir noktada, kendi probleminizin detaylarına dalabilirsiniz. Fakat bu size açgözlü bir algoritma için tipik bir doğruluk kanıtı yapısının anlaşılmasını sağlar.O ∗ O ∗$O_{i+1},O_{i+2},\dots,O_n$$O^*$$O^*$$O$

Basit bir örnek: Maksimum toplam ile altküme

Basit bir örnekle detaylı olarak çalışarak bunu anlamak daha kolay olabilir. Aşağıdaki sorunu göz önüne alalım:

Giriş: Bir tam sayı kümesi , bir tam sayı Çıkış: Toplam değeri olabildiğince büyük olan boyutunda bir küme kümesik S ⊆ U $U$$k$
$S \subseteq U$$k$

Bu problem için doğal bir açgözlü algoritma var:

1. Ayarı .$S := \emptyset$
2. For : $i := 1,2,\dots,k$
   • Let en büyük sayı henüz alınmamışsa (yani de inci büyük sayı ). Ekle için . U i U x i$x_i$$U$$i$$U$$x_i$$S$

Rastgele test, bunun her zaman en uygun çözümü verdiğini gösterir, bu yüzden bu algoritmanın doğru olduğunu resmen kanıtlayalım. En uygun çözümün benzersiz olduğunu, bu nedenle bağlar konusunda endişelenmemize gerek olmadığını unutmayın. Yukarıda belirtilen iddiayı ispatlayalım:

Talep: , bu algoritma tarafından ve girişlerinde en iyi çözüm olan çözüm çıktısı olsun . Eğer , o zaman başka bir çözüm gerçekleştirebilmesi miktarı toplamı daha büyük olan .U , k O S ≠ O O ∗$S$$U,k$$O$$S \ne O$$O^*$$O$

Kanıt. Varsayalım ve izin i ilk indeksi olarak yineleme burada X i ∉ O . (Böyle bir indeks i biz kabul ettik beri var olmalıdır S ≠ O ve algoritmanın tanım gereği sahip olduğumuz S = { x 1 , ... , x k } .) (Varsayımı ile) bu yana i minimal, biz olmalı x 1 , … , x i - 1 ∈ O ve özellikle$S \ne O$$i$$x_i \notin O$$i$$S \ne O$$S=\{x_1,\dots,x_k\}$$i$$x_1,\dots,x_{i-1} \in O$ , O = { x 1 , x 2 , … , x i - 1 , x ′ i , x ′ i + 1 , … , x ′ n } biçimine sahiptir, burada x 1 , … , x i - 1 , x ′ i , … , x ′ $O$$O=\{x_1,x_2,\dots,x_{i-1},x'_i,x'_{i+1},\dots,x'_n\}$$x_1,\dots,x_{i-1},x'_i,\dots,x'_n$azalan düzende listelenir. Algoritmanın nasıl seçtiğine baktığımızda, tüm j ≥ i için x i > x ′ j olması gerektiğini görüyoruz . Özellikle, x i > x ′ i . Bu nedenle tanımlama, O = O ∪ { x i } ∖ { x ' i } , yani elde ederiz O * silerek i inci sayısı $x_1,\dots,x_i$$x_i > x'_j$$j\ge i$$x_i > x'_i$$O^ = O \cup \{x_i\} \setminus \{x'_i\}$$O^*$$i$$O$ve ekleyerek . Şimdi elemanlarının toplamı O * elemanlarının toplamı O artı x i - X ' i , ve x i - x ' i > 0 , yani O * 'in toplamından daha kesin büyüktür O s toplamı'. Bu iddia kanıtlıyor. $x_i$$O^*$$O$$x_i-x'_i$$x_i-x'_i>0$$O^*$$O$$\blacksquare$

Buradaki sezgi, eğer açgözlü algoritma ile tutarlı olmayan bir seçim yaparsa, o zaman açgözlü algoritma tarafından seçilen öğeyi o aşamada içerecek şekilde değiştirilmişse O'nun daha iyi olabileceğini kanıtlayabiliriz . Yana Ç uygunudur geriye kalan tek ihtimal bizim varsayım yanlış olduğunu bu yüzden muhtemelen daha iyi (yani bir çelişki olurdu) yapmak için herhangi bir şekilde olamaz: başka bir deyişle, açgözlü algoritma bir seçim yapmak asla ile tutarsız o .$O$$O$$O$$O$

Bu argüman genellikle değişim argümanı veya değişim lemi olarak adlandırılır . İlk yerde bulunan burada hırslı çözeltiden uygun çözüm farklıdır ve bu alışveriş elemanının hayal (değiş tokuş karşılık gelen hırslı seçim için X ' i için x i ). Bazı analizler bu değişimin yalnızca en uygun çözümü geliştirebileceğini gösterdi - ancak tanım gereği, en uygun çözüm geliştirilemez. Dolayısıyla tek sonuç, optimal çözümün açgözlü çözümden farklı olduğu hiçbir yer olmaması gerektiğidir. Farklı bir probleminiz varsa, bu değişim prensibini sizin özel durumunuzda uygulama fırsatlarını araştırın.$O$$x'_i$$x_i$

Örnek olarak aşağıdaki basit sıralama algoritmasını kullanacağım:

repeat:
  if there are adjacent items in the wrong order:
     pick one such pair and swap
  else
     break

Doğruluğunu kanıtlamak için iki adım kullanıyorum.

• İlk önce algoritmanın daima sona erdiğini gösteriyorum.
• Sonra, sonlandırdığı çözümün istediğim çözüm olduğunu gösteriyorum.

İlk olarak, algoritmanın her adımda geliştirdiğini gösterebileceğim uygun bir maliyet fonksiyonu seçiyorum.

$A$$A[i]$$A[j]$$A[i] > A[j]$$i<j$

$A[i]$$A[i+1]$$A[i],A[i+1]$

Bu, algoritmanın sonunda sona erdiğini kanıtlar.

Sıralanan bir listedeki inversiyon sayısı 0'dır. Her şey yolunda giderse, algoritma inversiyon sayısını 0'a düşürür. Yalnızca yerel minimumda sıkışıp kalmayacağını göstermemiz gerekir.

Bunu genellikle çelişki ile kanıtlarım. Algoritmanın durduğunu, ancak çözümün doğru olmadığını kabul ediyorum. Örnekte, bu, listenin henüz sıralanmadığı, ancak yanlış sırada bitişik öğe olmadığı anlamına gelir.

$A[i]$$A[j]$$i<j$$A[i]>A[j]$$i$$j$$i+1 < j$$A[i]<A[i+1]$$A[i+1]<A[j]$$A[i]<A[j]$

Bu, algoritmanın yalnızca liste sıralandığında durduğunu kanıtlar. Ve bu yüzden bitti.