Algoritma analizinin büyüsünün ardında bir sistem var mı?

Algoritmaların çalışma zamanını nasıl analiz edeceğinizle ilgili birçok soru var (bkz. Örneğin çalışma zamanı analizi ve algoritma analizi ). Birçoğu, örneğin, iç içe döngüler için maliyet analizi veya bölme ve fethetme algoritmaları isteyenlere benzer, ancak çoğu cevap özel olarak yapılmış gibi görünmektedir.

Öte yandan, başka bir genel soruya verilen cevaplar , bazı örneklerle daha büyük resmi (özellikle de asimptotik analizle ilgili) açıklar, ancak ellerinizi nasıl kirleteceğinizi açıklamaz.

Algoritmaların maliyetini analiz etmek için yapısal, genel bir yöntem var mı? Maliyet, çalışma süresi (zaman karmaşıklığı) veya yapılan karşılaştırma sayısı, alan karmaşıklığı veya başka bir şey gibi başka bir maliyet ölçüsü olabilir.

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

Kodu Matematiğe Çevirmek

(Daha fazla veya daha az) resmi bir işlemsel anlambilim kuralı olarak, bir algoritmanın (sözde) kodunu kelimenin tam anlamıyla, ifadeyi yararlı bir forma sokabilmeniz koşuluyla size sonuç veren matematiksel bir ifadeye çevirebilirsiniz. Bu , karşılaştırma sayısı, takas, açıklama, hafıza erişimi, bazı soyut makinelerin ihtiyaç duyduğu döngüleri vb. İlave maliyet ölçümleri için iyi çalışır .

Örnek: Bubblesort'taki Karşılaştırmalar

Belirli bir diziyi sıralayan bu algoritmayı düşünün A:

 bubblesort(A) do                   1
  n = A.length;                     2
  for ( i = 0 to n-2 ) do           3
    for ( j = 0 to n-i-2 ) do       4
      if ( A[j] > A[j+1] ) then     5
        tmp    = A[j];              6
        A[j]   = A[j+1];            7
        A[j+1] = tmp;               8
      end                           9
    end                             10
  end                               11
end                                 12

Diyelim ki, sıralı sıralama algoritması analizini yapmak istiyoruz, bu da element karşılaştırma sayısını sayar (satır 5). Hemen bu miktarın, dizinin içeriğine bağlı olmadığını A, sadece uzunluğuna bağlı olduğunu not ediyoruz $n$. Böylece (yuvalanmış) forhalkaları tam anlamıyla (yuvalanmış) toplamlara çevirebiliriz; döngü değişkeni birleştirme değişkeni haline gelir ve aralık devam eder. Biz alırız:

,$\qquad\displaystyle C_{\text{cmp}}(n) = \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 1 = \dots = \frac{n(n-1)}{2} = \binom{n}{2}$

buradaki , 5. satırdaki her bir işlemin maliyetidir (ki biz sayarız).$1$

Örnek: Bubblesort'ta takaslar

Ben tarafından ifade edeceğiz hattından oluşmaktadır alt programı için ve tarafından C i , j bu alt programı (bir kez) yürütmek için maliyetleri.$P_{i,j}$ij$C_{i,j}$

Şimdi de saymak istediğiniz diyelim takaslarını , ne kadar sıklıkla yürütülür. Bu bir "temel blok", yani her zaman atomik olarak yürütülen ve sabit bir maliyeti olan bir alt programdır (burada, 1 ). Bu tür blokların sözleşme yapılması, genellikle düşünmeden veya konuşmadan uygulayacağımız kullanışlı bir basitleştirmedir.$P_{6,8}$$1$

Yukarıdaki gibi benzer bir çeviri ile aşağıdaki formüle geliyoruz:

.$\qquad\displaystyle C_{\text{swaps}}(A) = \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} C_{5,9}(A^{(i,j)})$

daha önce dizinin durumunu belirtmektedir ( i , j ) bir inci yineleme P 5 , 9 .$A^{(i,j)}$$(i,j)$$P_{5,9}$

Parametre olarak n yerine kullandığımı unutmayın ; Yakında neden göreceğiz. Ben katmayan i ve j parametreleri olarak C 5 , 9 (maliyetlerin beri burada onlara bağlı olmayan tek tip maliyet modeline yani); genel olarak, sadece olabilir.$A$$n$$i$$j$$C_{5,9}$

Açıktır ki, maliyeti içeriğine bağlıdır A (değerler ve özellikle de) bu nedenle bu hesaba gerekir. Şimdi bir zorlukla karşı karşıyayız: C 5 , 9'u nasıl açıyoruz ? A'nın içeriğine bağımlılığı yapabiliriz :$P_{5,9}$$A$A[j]A[j+1]$C_{5,9}$$A$

.$\qquad\displaystyle C_{5,9}(A^{(i,j)}) = C_5(A^{(i,j)}) + \begin{cases} 1 &, \mathtt{A^{(i,j)}[j] > A^{(i,j)}[j+1]} \\ 0 &, \text{else} \end{cases}$

Herhangi bir giriş dizisi için, bu maliyetler iyi tanımlanmıştır, ancak daha genel bir ifade istiyoruz; daha güçlü varsayımlarda bulunmamız gerekiyor. Üç tipik olayı araştıralım.

1. En kötü durum

   Sadece toplamı incelemek ve değerine dikkat çekerek, maliyet için önemsiz bir üst sınır bulabiliriz:$C_{5,9}(A^{(i,j)}) \in \{0,1\}$

   .$\qquad\displaystyle C_{\text{swaps}}(A) \leq \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 1 = \frac{n(n-1)}{2} = \binom{n}{2}$

   Ancak bu olabilir mi , yani bu üst sınırın elde edildiği için bir var mı? Görünen o ki, evet: tersine sıralanmış bir ikili ayrı eleman dizisi girersek, her yineleme bir takas gerçekleştirmelidir. Bu nedenle, bubblesort'un en kötü durumda olan takas sayısını kesin olarak belirledik.$A$

2. En iyi durum

   Tersine, önemsiz bir alt sınır var:

   .$\qquad\displaystyle C_{\text{swaps}}(A) \geq \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 0 = 0$

   Bu da olabilir: zaten sıralanan bir dizide, Bubblesort tek bir takas yürütmez.

3. Ortalama durum

   En kötü ve en iyi durum oldukça açık. Fakat tipik takas sayısı nedir? Bu soruyu cevaplamak için "tipik" ifadenin ne anlama geldiğini tanımlamamız gerekir. Teoride, bir girişi bir başkasına tercih etmek için hiçbir nedenimiz yoktur ve bu nedenle genellikle tüm olası girdiler üzerinde eşit bir dağılım olduğunu varsayıyoruz , bu da her girdi eşit derecede muhtemeldir. İkili ayrı elementler içeren dizileri kendimizle sınırlıyoruz ve böylece rastgele permütasyon modelini üstleniyoruz .

   Ardından, bu gibi masraflarımızı yeniden yazabiliriz:

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{n!} \sum_{A} \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} C_{5,9}(A^{(i,j)})$

   Şimdi toplamların basit manipülasyonunun ötesine geçmeliyiz. Algoritması bakarak, biz her takas tam olarak bir kaldırır dikkat inversiyon içinde (biz sadece hiç neighbours³ takas). Bu, üzerinde yapılan swap sayısını, A tam inversiyon sayısıdır inv ( A ) arasında bir . Böylece içsel iki toplamı değiştirebiliriz.$A$$A$$\operatorname{inv}(A)$$A$

   .$\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{n!} \sum_{A} \operatorname{inv}(A)$

   Şanslıyız ki, ortalama inversiyon sayısı

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{2} \cdot \binom{n}{2}$

   bu bizim nihai sonucumuz. Bunun en kötü durum maliyetinin yarısı kadar olduğuna dikkat edin.

1. Algoritmanın dikkatli bir şekilde formüle edildiğine dikkat edin i = n-1, dış döngü ile hiçbir şey yapmadan "son" yineleme yapılmaz.
2. $\mathbb{E}$
3. Biz o yol boyunca öğrenmek hayır sadece komşu elemanlarını değiştirir algoritma asimptotik hızlı (hatta ortalama olarak) BubbleSort daha olabilir - inversiyon sayısı bir alt sınır tür tüm algoritmalar içindir. Bu, örneğin Ekleme Sıralama ve Seçim Sıralama için geçerlidir .

Genel Yöntem

Örnekte kontrol yapısını matematiğe çevirmemiz gerektiğini gördük; Tipik bir çeviri kuralları topluluğu sunacağım. Ayrıca herhangi bir alt programın maliyetinin mevcut duruma bağlı olduğunu, yani değişkenlerin şu anki değerlerine (kabaca) bağlı olduğunu gördük . Algoritma (genellikle) durumu değiştirdiğinden, genel metot not almak için biraz hantaldır. Kafanız karıştıysa, örneğe geri dönmenizi veya kendinize ait bir şeyler yapmanızı öneririm.

Mevcut durumu ile gösteririz (bunu bir değişken atama kümesi olarak hayal edin). Bir programı çalıştırmak zaman durum başlangıç ψ , bir devlet sona ψ / P (Resim sonlandırır).$\psi$P$\psi$$\psi / \mathtt{P}$P

• Bireysel ifadeler

  S;$C_S(\psi)$

• İfade

  EFormun bir ifadesi varsa E1 ∘ E2(örneğin, ∘toplama veya çarpma olabilecek bir aritmetik ifade) , maliyetleri tekrarlı olarak eklersiniz:

  $\qquad\displaystyle C_E(\psi) = c_{\circ} + C_{E_1}(\psi) + C_{E_2}(\psi)$

  Bunu not et

  • $c_{\circ}$$E_1$$E_2$
  • ifadelerin değerlendirilmesi birçok dilde devleti değiştirebilir,

  bu kural ile esnek olmanız gerekebilir.

• Sıra

  PProgramların sırası olarak bir program göz önüne alındığında Q;R, maliyetleri

  $\qquad\displaystyle C_P(\psi) = C_Q(\psi) + C_R(\psi / \mathtt{Q})$

• Şartlılar

  PFormun bir programı göz önüne alındığında if A then Q else R end, maliyetler devlete bağlıdır:

  $\qquad\displaystyle C_P(\psi) = C_A(\psi) + \begin{cases} C_Q(\psi/\mathtt{A}) &, \mathtt{A} \text{ evaluates to true under } \psi \\ C_R(\psi/\mathtt{A}) &, \text{else} \end{cases}$

  Genel olarak, değerlendirme A, durumu çok iyi değiştirebilir, dolayısıyla bireysel branşların maliyetleri için güncelleme yapılabilir.

• -Loops için

  PFormun bir programı göz önüne alındığında for x = [x1, ..., xk] do Q end, maliyet atamak

  $\qquad\displaystyle C_P(\psi) = c_{\text{init_for}} + \sum_{i=1}^k c_{\text{step_for}} + C_Q(\psi_i \circ \{\mathtt{x := xi\}})$

  $\psi_i$Qxixx1xi-1

  $c_{\text{init_for}}$$c_{\text{step_for}}$

  • Bir sonraki hesaplama xipahalı olabilir ve
  • forBoş gövdeli bir döngü (örneğin, belirli bir maliyetle en iyi durum ayarında sadeleştirmeden sonra), yineleme yaparsa sıfır maliyeti yoktur.

• -Loops iken

  PFormun bir programı göz önüne alındığında while A do Q end, maliyet atamak

  $\qquad\displaystyle C_P(\psi) \\\qquad\ = C_A(\psi) + \begin{cases} 0 &, \mathtt{A} \text{ evaluates to false under } \psi \\ C_Q(\psi/\mathtt{A}) + C_P(\psi/\mathtt{A;Q}) &, \text{ else} \end{cases}$

  Algoritmayı inceleyerek, bu tekrarlama genellikle for-loop'lara benzer bir toplam olarak güzel bir şekilde gösterilebilir.

  Örnek: Bu kısa algoritmayı düşünün:

  while x > 0 do    1
    i += 1          2
    x = x/2         3
  end               4
  

  Kuralı uygulayarak alırız

  $\qquad\displaystyle C_{1,4}(\{i := i_0; x := x_0\}) \\\qquad\ = c_< + \begin{cases} 0 &, x_0 \leq 0 \\ c_{+=} + c_/ + C_{1,4}(\{i := i_0 + 1; x := \lfloor x_0/2 \rfloor\}) &, \text{ else} \end{cases}$

  $c_{\dots}$ix

  $C_{1,4}$i

  $\qquad\displaystyle C_{1,4}(x) = \begin{cases} c_> &, x \leq 0 \\ c_> + c_{+=} + c_/ + C_{1,4}(\lfloor x/2 \rfloor) &, \text{ else} \end{cases}$

  Bu birlikte çözer temel aracı için

  $\qquad\displaystyle C_{1,4}(\psi) = \lceil \log_2 \psi(x) \rceil \cdot (c_> + c_{+=} + c_/) + c_>$

  $\psi = \{ \dots, x := 5, \dots\}$$\psi(x) = 5$

• Prosedür Çağrıları

  Bazı parametreler Piçin formun bir programı verildiğinde , (adlandırılmış) parametresiyle bir prosedür olan maliyetler atayınM(x)xMp

  $\qquad\displaystyle C_P(\psi) = c_{\text{call}} + C_M(\psi_{\text{glob}} \circ \{p := x\})$

  $c_{\text{call}}$$\psi$

  Buradaki devletle ilgili olabilecek bazı anlamsal sorunları anlatıyorum. Küresel durumu ve bu tür yerel işlemleri prosedür çağrılarına göre ayırt etmek isteyeceksiniz. Sadece biz burada sadece küresel devlet geçmek ve varsayalım Mdeğerini ayarlayarak başlatıldı yeni bir yerel devlet, alır piçin x. Ayrıca, x(genellikle) geçmeden önce değerlendirmeyi düşündüğümüz bir ifade olabilir.

  Örnek: Prosedürü düşünün

  fac(n) do                  
    if ( n <= 1 ) do         1
      return 1               2
    else                     3
      return n * fac(n-1)    4
    end                      5
  end                        
  

  Kurallara göre:

  $\qquad\displaystyle\begin{align*} C_{\text{fac}}(\{n := n_0\}) &= C_{1,5}(\{n := n_0\}) \\ &= c_{\leq} + \begin{cases} C_2(\{n := n_0 \}) &, n_0 \leq 1 \\ C_4(\{n := n_0 \}) &, \text{ else} \end{cases} \\ &= c_{\leq} + \begin{cases} c_{\text{return}} &, n_0 \leq 1 \\ c_{\text{return}} + c_* + c_{\text{call}} + C_{\text{fac}}(\{n := n_0 - 1\}) &, \text{ else} \end{cases} \end{align*}$

  facHiçbir şekilde erişemediği için küresel devleti göz ardı ettiğimizi unutmayın . Bu özel yinelemenin çözülmesi kolaydır

  $\qquad\displaystyle C_{\text{fac}}(\psi) = \psi(n) \cdot (c_{\leq} + c_{\text{return}}) + (\psi(n) - 1) \cdot (c_* + c_{\text{call}})$

Tipik sözde kodla karşılaşacağınız dil özelliklerini ele aldık. Üst düzey sahte kodu analiz ederken gizli maliyetlere dikkat edin; şüphe durumunda, açılmak. Notasyon hantal görünebilir ve kesinlikle bir zevk meselesidir; Yine de listelenen kavramlar göz ardı edilemez. Bununla birlikte, bazı deneyimlerle, devletin hangi kısımlarının hangi maliyet ölçüsü için uygun olduğunu hemen görebileceksiniz, örneğin "sorun boyutu" veya "tepe noktası sayısı". Gerisi düşebilir - bu işleri önemli ölçüde kolaylaştırır!

Bu çok karmaşık olduğunu şimdi düşünüyorsanız, tavsiye edilebilir: Bu olduğunu ! Gerçek zamanlı makinelere çalışma süresi tahminlerini (göreceli olanlar bile) mümkün kılacak kadar yakın olan herhangi bir modelde algoritmaların kesin maliyetlerini türetmek zor bir çabadır. Ve bu, gerçek makineler üzerindeki önbellekleme ve diğer kötü etkileri dikkate almıyor bile.

Bu nedenle, algoritma analizi genellikle matematiksel olarak izlenebilir olma noktasına göre basitleştirilmiştir. Örneğin, kesin bir maliyete ihtiyacınız yoksa, herhangi bir noktada (üst ve alt sınırlar için) aşırı veya düşük tahmin edebilirsiniz: sabitleri azaltın, koşullardan kurtulun, toplamları basitleştirin, vb.

Asimptotik maliyet notu

$n$

Bu (genellikle) adildir, çünkü soyut ifadeler , makineye, işletim sistemine ve diğer faktörlere bağlı olarak gerçekte bazı (genel olarak bilinmeyen) maliyetlere sahiptir ve işlemi ilk etapta ve ne olursa olsun yapan işletim sistemi tarafından kısa çalışma sürelerine hâkim olabilir. Zaten biraz sapkınlık yaşarsın.

Asimptotik analizin bu yaklaşımla ilişkisi:

1. Tanımlayın baskın , yani (sabit faktörlere kadar) en sık ortaya operasyonlar (yani maliyetleri teşvik) işlemleri. Bubblesort örneğinde, olası bir seçenek, 5. satırdaki karşılaştırmadır.

   Alternatif olarak, temel işlemler için tüm sabitleri en fazla (yukarıdan) karşılık olarak bağlarlar. minimum (aşağıdan) ve normal analiz yapın.

2. Bu işlemin yürütme sayılarını maliyet olarak kullanarak analizi gerçekleştirin.
3. $O$$\Omega$

$O$

daha fazla okuma

Algoritma analizinde daha birçok zorluk ve püf noktası var. İşte önerilen bazı okumalar.

• Algoritmaların çalışma süresi nasıl ortaya çıkar?
  Algoritmaları nasıl tarif eder, ispatlar ve analiz eder?
• İki algoritmayı karşılaştırmak için neden çalışma zamanı yerine karşılaştırmalar kullanıyorsunuz?
  Sayılardaki temel işlemlerin zaman alacağını nasıl varsayabiliriz?
  Çalışma zamanı analizinde bir zaman birimi ne oluşturur?
• Sayı dizileri için nüks ilişkilerini çözme veya yaklaşık değerleme
• İtfa Edilen Analizin Temelleri

Algoritma analizi etiketli birçok soru var, buna benzer teknikler kullanıyor.

İcra İfadeleri

Bilgisayar Programcılığı Sanatı programında Donald E. Knuth tarafından öne sürülen başka bir yöntem daha var . Tüm algoritmayı tek bir formüle çevirmenin aksine , “şeyleri bir araya getirmek” tarafındaki kodun anlambiliminden bağımsız olarak çalışır ve "kartal gözü" görünümünden başlayarak yalnızca gerektiğinde daha düşük bir seviyeye gitmesine izin verir. Her ifade diğerlerinden bağımsız olarak analiz edilebilir ve böylece daha net hesaplamalar yapılabilir. Bununla birlikte, teknik, çok daha yüksek seviye sözde koduna değil, oldukça ayrıntılı koda kendisini iyi verir.

Yöntem

Prensip olarak oldukça basit:

1. Her ifadeye bir ad / numara atayın.
2. $S_i$$C_i$
3. $S_i$$e_i$

4. Toplam maliyetleri hesapla

   $\qquad\displaystyle C = \sum_{i} e_i \cdot C_i$

Tahminleri ve / veya sembolik büyüklükleri herhangi bir noktaya ekleyebilirsiniz, cevap verebiliriz. sonucun buna göre genelleştirilmesi.

$e_{77} \in O(n \log n)$

Örnek: Derinlik ilk arama

Aşağıdaki grafik geçiş algoritmasını göz önünde bulundurun:

dfs(G, s) do
  // assert G.nodes contains s
  visited = new Array[G.nodes.size]     1
  dfs_h(G, s, visited)                  2
end 

dfs_h(G, s, visited) do
  foo(s)                                3
  visited[s] = true                     4

  v = G.neighbours(s)                   5
  while ( v != nil ) do                 6
    if ( !visited[v] ) then             7
      dfs_h(G, v, visited)              8
    end
    v = v.next                          9
  end
end

$\{0,\dots,n-1\}$$m$

$A$$B$$C$$e_i$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline e_i & A & A & B & B & B & B+C & C & B-1 & C \end{array}$

$e_8 = e_3-1$foodfs$e_6 = e_5 + e_7$while

$A=1$foo$B = n$$C = 2m$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline e_i & 1 & 1 & n & n & n & 2m + n & 2m & n-1 & 2m \end{array}$

Bu bizi tam olarak toplam maliyete götürür

$\qquad\begin{align*} C(n,m) = (C_1 + C_2 - C_8) &+\ n \cdot (C_3 + C_4 + C_5 + C_6 + C_8) \\ &+\ 2m \cdot (C_6 + C_7 + C_9) \;. \end{align*}$

$C_i$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline C_i & n & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 1 \end{array}$

ve Al

$\qquad\displaystyle C_{\text{mem}}(n,m) = 3n + 4m$

daha fazla okuma

Diğer cevabımın alt kısmına bakınız .

Algoritma analizi, teorem ispatlama gibi, büyük ölçüde bir sanattır (örneğin, nasıl analiz edeceğimizi bilmediğimiz basit programlar vardır ( Collatz problemi gibi )). Bir algoritma karmaşıklığı problemini, Raphael tarafından kapsamlı bir şekilde cevaplandırıldığı gibi matematiksel bir soruna dönüştürebiliriz , ancak daha sonra bilinen fonksiyonlar açısından bir algoritmanın maliyetine bağlılığı ifade etmek için:

1. Mevcut analizlerden bildiğimiz teknikleri kullanın; örneğin, anladığımız yinelemelere dayalı sınırları bulma veya hesaplayabildiğimiz / toplayabildiğimiz toplamları.
2. Algoritmayı nasıl analiz edeceğimizi bildiğimiz bir şeyle değiştirin.
3. Tamamen yeni bir yaklaşımla gelin.