Böl ve Conquer Algoritmaları ile Dinamik Programlama Algoritmaları arasındaki fark nedir? İki terim nasıl farklı? Aralarındaki farkı anlamıyorum.
Lütfen ikisi arasındaki farkları ve hangi zeminde benzer olduklarını açıklamak için basit bir örnek alın.
Yanıtlar:
Böl ve fethet
Divide and Conquer, problemi alt problemlere bölerek, her bir alt problemi özyinelemeli olarak ele geçirir ve bu çözümleri birleştirir.
Dinamik program
Dinamik Programlama, çakışan alt problemlerle ilgili problemleri çözmek için bir tekniktir. Her alt sorun yalnızca bir kez çözülür ve her alt sorunun sonucu gelecekteki referanslar için bir tabloda (genellikle bir dizi veya karma tablosu olarak uygulanır) saklanır. Bu alt çözeltiler, orijinal çözeltiyi elde etmek için kullanılabilir ve alt problemli çözeltileri saklama tekniği, hafızaya alma olarak bilinir.
Düşünebilirsin DP = recursion + re-use
Farkı anlamak için klasik bir örnek, nci fibonacci sayısının elde edilmesine yönelik her iki yaklaşımı da görmek olacaktır. Bu malzemeyi MIT'den kontrol edin .
Böl ve Fethet yaklaşımı
Dinamik Programlama Yaklaşımı
Böl ve fethet ve dinamik programlama arasındaki diğer fark şunlar olabilir:
Böl ve fethet:
Dinamik program:
bazen özyinelemeli olarak programlama yaparken, aynı parametrelerle fonksiyonu birden çok kez çağırırsınız, bu da gereksizdir.
Ünlü örnek Fibonacci sayıları:
index: 1,2,3,4,5,6...
Fibonacci number: 1,1,2,3,5,8...
function F(n) {
if (n < 3)
return 1
else
return F(n-1) + F(n-2)
}
Hadi F (5):
F(5) = F(4) + F(3)
= {F(3)+F(2)} + {F(2)+F(1)}
= {[F(2)+F(1)]+1} + {1+1}
= 1+1+1+1+1
Bu yüzden aradık: 1 kez F (4) 2 kez F (3) 3 kez F (2) 2 kez F (1)
Dinamik Programlama yaklaşımı: Aynı parametreye sahip bir işlevi bir kereden fazla çağırırsanız, bir dahaki sefere doğrudan erişmek için sonucu bir değişkene kaydedin. Yinelemeli yol:
if (n==1 || n==2)
return 1
else
f1=1, f2=1
for i=3 to n
f = f1 + f2
f1 = f2
f2 = f
Tekrar F (5) 'i arayalım:
fibo1 = 1
fibo2 = 1
fibo3 = (fibo1 + fibo2) = 1 + 1 = 2
fibo4 = (fibo2 + fibo3) = 1 + 2 = 3
fibo5 = (fibo3 + fibo4) = 2 + 3 = 5
Gördüğünüz gibi, birden fazla çağrıya ihtiyacınız olduğunda, değeri yeniden hesaplamak yerine karşılık gelen değişkene erişirsiniz.
Bu arada, dinamik programlama yinelemeli bir kodu yinelemeli bir koda dönüştürmek anlamına gelmez. Özyinelemeli bir kod istiyorsanız, alt sonuçları bir değişkene de kaydedebilirsiniz. Bu durumda tekniğe notlama denir. Örneğimiz için şöyle görünüyor:
// declare and initialize a dictionary
var dict = new Dictionary<int,int>();
for i=1 to n
dict[i] = -1
function F(n) {
if (n < 3)
return 1
else
{
if (dict[n] == -1)
dict[n] = F(n-1) + F(n-2)
return dict[n]
}
}
Divide and Conquer ile olan ilişki, D&D algoritmalarının özyinelemeye dayanmasıdır. Ve bazı sürümlerinde bu "aynı parametre sorunu ile çok işlevli çağrı" var. D&D algo'nun T (n) 'sini iyileştirmek için DP'nin gerekli olduğu bu tür örnekler için "matris zinciri çarpımı" ve "en uzun ortak alt diziyi" arayın.
Şimdilik gördüğüm gibi, dinamik programlamanın bölün ve fethet paradigmasının bir uzantısı olduğunu söyleyebilirim .
Onlara tamamen farklı bir şeymiş gibi davranmam. Çünkü her ikisi de, bir sorunu doğrudan veya çözülecek kadar basit hale gelinceye kadar aynı ya da ilgili türdeki iki ya da daha fazla alt soruna tekrar tekrar bölerek çalışırlar . Daha sonra alt problemlerin çözümleri birleştirilerek orijinal probleme bir çözüm elde edilir.
Öyleyse neden hala farklı paradigma isimlerimiz var ve neden dinamik programlamayı bir uzantı olarak adlandırdım. Bunun nedeni, dinamik programlama yaklaşımının soruna ancak sorunun belirli kısıtlamaları veya önkoşulları olması durumunda uygulanabilmesidir . Ve bundan sonra dinamik programlama, bölme ve fethetme yaklaşımını notlama veya tablolama tekniği ile genişletir .
Adım adım gidelim…
Az önce keşfettiğimiz gibi, dinamik programlamanın uygulanabilmesi için bölme ve ele geçirme sorununun sahip olması gereken iki temel özellik vardır:
Optimal altyapı - alt problemlerinin optimum çözümlerinden optimum çözüm oluşturulabilir
Çakışan alt problemler - problem, birkaç kez yeniden kullanılan alt problemlere ayrılabilir veya problem için yinelenen bir algoritma, her zaman yeni alt problemler üretmek yerine aynı alt problemi tekrar tekrar çözer
Bu iki koşul gerçekleştiğinde, bu bölme ve fethetme sorununun dinamik programlama yaklaşımı kullanılarak çözülebileceğini söyleyebiliriz.
Dinamik programlama yaklaşımı, bölme ve fethetme yaklaşımını, performansı önemli ölçüde artırabilecek alt sorun çözümlerini depolama ve yeniden kullanma amacına sahip iki teknikle ( notlama ve tablolama ) genişletir . Örneğin, Fibonacci fonksiyonunun saf özyinelemeli uygulaması, O(2^n)DP çözümünün sadece O(n)zamanla aynı şeyi yaptığı zaman karmaşıklığına sahiptir .
Memoization (yukarıdan aşağıya önbellek doldurma) , önceden hesaplanmış sonuçların önbelleğe alınması ve yeniden kullanılması tekniğini ifade eder. Kaydedilen fibişlev bu şekilde şöyle görünecektir:
memFib(n) {
if (mem[n] is undefined)
if (n < 2) result = n
else result = memFib(n-2) + memFib(n-1)
mem[n] = result
return mem[n]
}
Tablolama (aşağıdan yukarıya önbellek doldurma) benzerdir ancak önbellek girişlerini doldurmaya odaklanır. Önbellekteki değerleri hesaplamak en kolay şekilde yinelemeli olarak yapılır. Tablolama sürümü fibşöyle görünecektir:
tabFib(n) {
mem[0] = 0
mem[1] = 1
for i = 2...n
mem[i] = mem[i-2] + mem[i-1]
return mem[n]
}
Not alma ve tablo karşılaştırma hakkında daha fazla bilgiyi buradan edinebilirsiniz .
Burada kavramanız gereken ana fikir, bölme ve fethetme sorunumuzun çakışan alt problemlere sahip olması, alt problem çözümlerinin önbelleğe alınmasının mümkün hale gelmesi ve böylece not / tablonun sahneye çıkmasıdır.
Artık DP önkoşullarını ve metodolojilerini bildiğimiz için yukarıda belirtilenlerin tümünü tek bir resme koymaya hazırız.
Kod örneklerini görmek istiyorsanız, burada iki algoritma örneği bulacağınız daha ayrıntılı açıklamaya göz atabilirsiniz : DP ve DC arasındaki farkı gösteren İkili Arama ve Minimum Düzenleme Mesafesi (Levenshtein Mesafesi).
Bu konuda Wikipedia'yı ve diğer akademik kaynakları zaten okuduğunuzu varsayıyorum, bu yüzden bu bilgileri geri dönüştürmeyeceğim. Ayrıca hiçbir şekilde bir bilgisayar bilimi uzmanı olmadığımı da söylemeliyim, ancak iki sentimi bu konuları anladığım konusunda paylaşacağım ...
Sorunu ayrık alt problemlere böler. Fibonacci dizisi için özyinelemeli algoritma Dinamik Programlamaya bir örnektir, çünkü fib (n) için önce fib (n-1) için çözerek çözer. Orijinal problemi çözmek için farklı bir problem çözer .
Bu algoritmalar tipik olarak sorunun benzer parçalarını çözer ve sonunda onları bir araya getirir. Mergesort, bölünme ve fethetmenin klasik bir örneğidir. Bu örnek ve Fibonacci örneği arasındaki temel fark, bir birleşmede, bölünmenin (teorik olarak) keyfi olabilmesidir ve nasıl dilimlediğinize bakılmaksızın, hala birleştiriyor ve sıralıyorsunuz. Diziyi nasıl böldüğünüz önemli değil, diziyi birleştirmek için aynı miktarda iş yapılmalıdır. Fib (52) için çözme, fib (2) için çözmekten daha fazla adım gerektirir .
Ben Divide & Conquerözyinelemeli bir yaklaşım ve Dynamic Programmingtablo doldurma olarak düşünüyorum .
Örneğin Merge Sort, bir Divide & Conqueralgoritmadır, her adımda olduğu gibi, diziyi iki yarıya böldünüz, iki yarıyı tekrar tekrar çağırır Merge Sortve birleştirirsiniz.
KnapsackDynamic Programminggenel sırt çantasının alt sorunlarına en uygun çözümleri temsil eden bir tabloyu doldururken bir algoritmadır. Tablodaki her bir giriş, 1-j maddelerinde verilen ağırlıkça bir torbada taşıyabileceğiniz maksimum değere karşılık gelir.
Divide and Conquer , her özyineleme düzeyinde üç adım içerir:
Dinamik Programlama aşağıdaki dört adımı içerir:
1. En uygun çözümlerin yapısını karakterize edin.
2. Optimal çözümlerin değerlerini tekrar tekrar tanımlayın .
3. En uygun çözümlerin değerini hesaplayın .
4. Construct bir Optimal Çözüm bilgisayarlı bilgilerden .
Daha kolay anlaşılması için, böl ve fethetmeyi kaba kuvvet çözümü ve optimizasyonunu dinamik programlama olarak görelim.
Çakışan alt problemlere sahip
NB bölme ve fethetme algoritmaları sadece dp ile optimize edilebilir.
fact(5) = 5* fact(4) = 5 * (4 * fact(3))= 5 * 4 * (3 *fact(2))= 5 * 4 * 3 * 2 * (fact(1))
Yukarıda görebildiğimiz gibi, hiçbir gerçek (x) tekrarlanmamaktadır, bu yüzden faktöriyel örtüşmeyen problemlere sahiptir.
fib(5) = fib(4) + fib(3) = (fib(3)+fib(2)) + (fib(2)+fib(1))
Yukarıda görebildiğimiz gibi, fib (4) ve fib (3) her ikisi de fib (2) kullanır. benzer şekilde çok fazla fib (x) tekrarlanır. bu yüzden Fibonacci'nin çakışan alt problemleri vardır.