Apakah ada sistem di balik keajaiban analisis algoritma?

Ada banyak pertanyaan tentang bagaimana menganalisis waktu berjalan algoritma (lihat, misalnya, analisis runtime dan analisis algoritma ). Banyak yang serupa, misalnya yang meminta analisis biaya loop bersarang atau algoritma Divide & Conquer, tetapi sebagian besar jawaban tampaknya dibuat khusus.

Di sisi lain, jawaban untuk pertanyaan umum lainnya menjelaskan gambaran yang lebih besar (khususnya mengenai analisis asimptotik) dengan beberapa contoh, tetapi tidak bagaimana cara membuat tangan Anda kotor.

Apakah ada metode umum terstruktur untuk menganalisis biaya algoritma? Biaya mungkin waktu berjalan (kompleksitas waktu), atau ukuran biaya lainnya, seperti jumlah perbandingan yang dilakukan, kompleksitas ruang, atau sesuatu yang lain.

^{Ini seharusnya menjadi referensi pertanyaan yang dapat digunakan untuk mengarahkan pemula; karenanya cakupannya lebih luas dari biasanya. Harap berhati-hati untuk memberikan jawaban umum, yang disajikan secara didaktis yang diilustrasikan oleh setidaknya satu contoh tetapi tetap mencakup banyak situasi. Terima kasih!}

Menerjemahkan Kode ke Matematika

Diberikan (kurang lebih) semantik operasional formal Anda dapat menerjemahkan kode algoritma (pseudo-) secara harfiah ke dalam ekspresi matematika yang memberi Anda hasilnya, asalkan Anda dapat memanipulasi ekspresi menjadi bentuk yang bermanfaat. Ini bekerja dengan baik untuk ukuran biaya tambahan seperti jumlah perbandingan, swap, pernyataan, akses memori, siklus beberapa kebutuhan mesin abstrak, dan sebagainya.

Contoh: Perbandingan di Bubblesort

Pertimbangkan algoritma ini yang mengurutkan array yang diberikan 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

Katakanlah kita ingin melakukan analisis algoritma penyortiran yang biasa, yaitu menghitung jumlah perbandingan elemen (baris 5). Kami segera mencatat bahwa jumlah ini tidak bergantung pada konten array A, hanya pada panjangnya . Jadi kita bisa menerjemahkan (nested) -lompatan secara harfiah ke dalam jumlah (nested); variabel loop menjadi variabel penjumlahan dan rentang membawa. Kita mendapatkan:$n$for

$\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}$ ,

di mana adalah biaya untuk setiap eksekusi baris 5 (yang kami hitung).$1$

Contoh: Swap dalam Bubblesort

Saya akan menyatakan dengan subprogram yang terdiri dari baris ke dan oleh biaya untuk menjalankan subprogram ini (satu kali).$P_{i,j}$ij$C_{i,j}$

Sekarang katakanlah kita ingin menghitung swap , yaitu seberapa sering dieksekusi. Ini adalah "blok dasar", yaitu subprogram yang selalu dijalankan secara atom dan memiliki biaya konstan (di sini, ). Mengontrak blok semacam itu adalah salah satu penyederhanaan yang berguna yang sering kita terapkan tanpa memikirkan atau membicarakannya.$P_{6,8}$$1$

Dengan terjemahan yang sama seperti di atas, kita sampai pada rumus berikut:

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

$A^{(i,j)}$ menunjukkan keadaan array sebelum -terulangan ke- .$(i,j)$$P_{5,9}$

Perhatikan bahwa saya menggunakan sebagai ganti sebagai parameter; kita akan segera melihat alasannya. Saya tidak menambahkan dan sebagai parameter karena biaya tidak tergantung pada mereka di sini (dalam model biaya seragam , yaitu); secara umum, mereka mungkin saja.$A$$n$$i$$j$$C_{5,9}$

Jelas, biaya tergantung pada konten (nilai-nilai dan , khususnya) jadi kami harus memperhitungkannya. Sekarang kita menghadapi tantangan: bagaimana kita "membuka" ? Nah, kita bisa membuat ketergantungan pada konten eksplisit:$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}$ .

Untuk setiap array input yang diberikan, biaya-biaya ini didefinisikan dengan baik, tetapi kami ingin pernyataan yang lebih umum; kita perlu membuat asumsi yang lebih kuat. Mari kita selidiki tiga kasus khas.

1. Kasus terburuk

   Hanya dari melihat jumlah dan mencatat bahwa , kita dapat menemukan batas atas sepele untuk biaya:$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}$ .

   Tetapi dapatkah ini terjadi , yaitu adakah untuk batas atas ini tercapai? Ternyata, ya: jika kita memasukkan array yang diurutkan terbalik dari elemen berbeda berpasangan, setiap iterasi harus melakukan swap¹. Oleh karena itu, kami telah mendapatkan jumlah swap terburuk yang tepat untuk Bubblesort.$A$

2. Kasus terbaik

   Sebaliknya, ada batas bawah sepele:

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

   Ini juga dapat terjadi: pada array yang sudah diurutkan, Bubblesort tidak menjalankan satu swap.

3. Kasus rata-rata

   Kasus terburuk dan terbaik membuka cukup celah. Tapi apa adalah khas jumlah swap? Untuk menjawab pertanyaan ini, kita perlu mendefinisikan apa arti "khas". Secara teori, kami tidak memiliki alasan untuk lebih memilih satu input daripada input lainnya dan oleh karena itu kami biasanya mengasumsikan distribusi yang seragam atas semua input yang mungkin, yaitu setiap input memiliki kemungkinan yang sama besar. Kami membatasi diri untuk array dengan elemen berbeda berpasangan dan dengan demikian mengasumsikan model permutasi acak .

   Kemudian, kami dapat menulis ulang biaya kami seperti ini²:

   $\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)})$

   Sekarang kita harus melampaui manipulasi jumlah yang sederhana. Dengan melihat algoritma, kami mencatat bahwa setiap swap menghapus tepat satu inversi dalam (kami hanya pernah bertukar tetangga )³. Artinya, jumlah swap dilakukan pada adalah persis jumlah inversi dari . Dengan demikian, kita dapat mengganti dua jumlah dalam dan mendapatkan$A$$A$$\operatorname{inv}(A)$$A$

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

   Beruntung bagi kami, jumlah rata-rata inversi telah ditentukan

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

   yang merupakan hasil akhir kami. Perhatikan bahwa ini persis setengah dari biaya terburuk.

1. Perhatikan bahwa algoritma dirumuskan dengan cermat sehingga iterasi "yang terakhir" dengan i = n-1loop luar yang tidak pernah melakukan apa pun tidak dieksekusi.
2. " " adalah notasi matematika untuk "nilai yang diharapkan", yang di sini hanya rata-rata.$\mathbb{E}$
3. Kami belajar sepanjang jalan bahwa tidak ada algoritma yang hanya menukar elemen tetangga dapat secara asimptotik lebih cepat daripada Bubblesort (bahkan rata-rata) - jumlah inversi adalah batas yang lebih rendah untuk semua algoritma tersebut. Ini berlaku untuk mis. Penyortiran dan Penyortiran Pilihan .

Metode Umum

Kita telah melihat dalam contoh bahwa kita harus menerjemahkan struktur kontrol ke dalam matematika; Saya akan menyajikan ansambel khas aturan terjemahan. Kita juga telah melihat bahwa biaya dari setiap subprogram yang diberikan mungkin tergantung pada keadaan saat ini , yaitu (kira-kira) nilai variabel saat ini. Karena algoritma (biasanya) memodifikasi keadaan, metode umum sedikit rumit untuk diketahui. Jika Anda mulai merasa bingung, saya sarankan Anda kembali ke contoh atau membuat sendiri.

Kami menyatakan dengan keadaan saat ini (bayangkan sebagai seperangkat tugas variabel). Ketika kami menjalankan program yang dimulai dengan status , kami berakhir dengan status (disediakan berakhir).$\psi$P$\psi$$\psi / \mathtt{P}$P

• Pernyataan individu

  Diberi hanya satu pernyataan S;, Anda menetapkan biaya . Ini biasanya akan menjadi fungsi konstan.$C_S(\psi)$

• Ekspresi

  Jika Anda memiliki ekspresi Eformulir E1 ∘ E2(misalnya, ekspresi aritmatika di mana ∘mungkin penambahan atau penggandaan, Anda menambahkan biaya secara rekursif:

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

  Catat itu

  • biaya operasi mungkin tidak konstan tetapi tergantung pada nilai dan dan$c_{\circ}$$E_1$$E_2$
  • evaluasi ekspresi dapat mengubah keadaan dalam banyak bahasa,

  jadi Anda mungkin harus fleksibel dengan aturan ini.

• Urutan

  Diberikan program Psebagai urutan program Q;R, Anda menambahkan biaya

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

• Persyaratan

  Diberikan program Pformulir if A then Q else R end, biaya tergantung pada negara:

  $\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}$

  Secara umum, mengevaluasi Amungkin sangat mengubah keadaan, sehingga pembaruan untuk biaya masing-masing cabang.

• For-Loops

  Diberikan program Pformulir for x = [x1, ..., xk] do Q end, tetapkan biaya

  $\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\}})$

  di mana adalah status sebelum memproses untuk nilai , yaitu setelah iterasi dengan diatur ke , ..., .$\psi_i$Qxixx1xi-1

  Perhatikan konstanta tambahan untuk pemeliharaan loop; variabel loop harus dibuat ( ) dan menetapkan nilainya ( )). Ini relevan sejak$c_{\text{init_for}}$$c_{\text{step_for}}$

  • komputasi berikutnya ximungkin mahal dan
  • a for-Lingkaran dengan tubuh kosong (misalnya setelah menyederhanakan dalam kasus terbaik dengan biaya tertentu) tidak memiliki biaya nol jika melakukan iterasi.

• Sementara-Loops

  Diberikan program Pformulir while A do Q end, tetapkan biaya

  $\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}$

  Dengan memeriksa algoritme, perulangan ini sering kali dapat direpresentasikan dengan baik sebagai jumlah yang mirip dengan perulangan for-loop.

  Contoh: Pertimbangkan algoritma singkat ini:

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

  Dengan menerapkan aturan, kita dapatkan

  $\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}$

  dengan beberapa biaya konstan untuk masing-masing pernyataan. Kami berasumsi secara implisit bahwa ini tidak tergantung pada negara (nilai-nilai dan ); ini mungkin atau mungkin tidak benar dalam "kenyataan": pikirkan tentang luapan!$c_{\dots}$ix

  Sekarang kita harus menyelesaikan pengulangan ini untuk . Kami mencatat bahwa baik jumlah iterasi bukan biaya loop body bergantung pada nilai , sehingga kami dapat menjatuhkannya. Kita dibiarkan dengan pengulangan ini:$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}$

  Ini diselesaikan dengan sarana dasar untuk

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

  memperkenalkan kembali kondisi penuh secara simbolis; jika , maka .$\psi = \{ \dots, x := 5, \dots\}$$\psi(x) = 5$

• Panggilan Prosedur

  Diberikan program Pformulir M(x)untuk beberapa parameter di xmana Mprosedur dengan parameter (bernama) p, menetapkan biaya

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

  Catat lagi konstanta tambahan (yang mungkin sebenarnya bergantung pada !). Panggilan prosedur mahal karena bagaimana mereka diterapkan pada mesin nyata, dan kadang-kadang bahkan mendominasi runtime (misalnya mengevaluasi pengulangan angka Fibonacci secara naif).$c_{\text{call}}$$\psi$

  Saya membahas beberapa masalah semantik yang mungkin Anda miliki dengan keadaan di sini. Anda akan ingin membedakan negara global dan lokal untuk panggilan prosedur. Mari kita asumsikan kita hanya melewati negara global di sini dan Mmendapat negara lokal baru, diinisialisasi dengan menetapkan nilai pto x. Lebih jauh, xmungkin ungkapan yang kita (biasanya) asumsikan dievaluasi sebelum melewatinya.

  Contoh: Pertimbangkan prosedurnya

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

  Sesuai aturan, kami mendapatkan:

  $\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*}$

  Perhatikan bahwa kami mengabaikan negara global, karena facjelas tidak mengaksesnya. Perulangan khusus ini mudah dipecahkan

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

Kami telah membahas fitur bahasa yang akan Anda temui dalam kode pseudo yang khas. Waspadai biaya tersembunyi ketika menganalisis kode pseudo tingkat tinggi; jika ragu, buka. Notasi tersebut mungkin terlihat rumit dan tentu saja merupakan masalah selera; konsep-konsep yang tercantum tidak dapat diabaikan. Namun, dengan beberapa pengalaman Anda akan dapat melihat langsung bagian mana dari negara yang relevan untuk ukuran biaya mana, misalnya "ukuran masalah" atau "jumlah simpul". Sisanya dapat dijatuhkan - ini menyederhanakan banyak hal!

Jika Anda berpikir sekarang bahwa ini terlalu rumit, disarankan: itu adalah ! Turunkan biaya tepat dari algoritma dalam model apa pun yang begitu dekat dengan mesin nyata sehingga memungkinkan prediksi runtime (bahkan yang relatif) adalah upaya yang sulit. Dan itu bahkan tidak mempertimbangkan caching dan efek buruk lainnya pada mesin nyata.

Oleh karena itu, analisis algoritme sering disederhanakan sampai titik yang dapat ditelusur secara matematis. Misalnya, jika Anda tidak memerlukan biaya yang pasti, Anda bisa melebih-lebihkan atau meremehkan pada titik mana pun (untuk batas atas, batas bawah): kurangi set konstanta, singkirkan persyaratan, sederhanakan penjumlahan, dan sebagainya.

Catatan tentang biaya asimptotik

Apa yang biasanya Anda temukan dalam literatur dan di web adalah "Analisis Besar-Oh". Istilah yang tepat adalah analisis asimptotik yang berarti bahwa alih-alih mendapatkan biaya yang tepat seperti yang kami lakukan dalam contoh, Anda hanya memberikan biaya hingga faktor konstan dan dalam batas (secara kasar, "untuk besar ").$n$

Ini (sering) adil karena pernyataan abstrak memiliki beberapa (umumnya tidak diketahui) biaya dalam kenyataan, tergantung pada mesin, sistem operasi dan faktor lainnya, dan runtime pendek dapat didominasi oleh sistem operasi yang mengatur proses di tempat pertama dan yang lainnya. Jadi, Anda mendapatkan sedikit gangguan.

Inilah bagaimana analisis asimptotik berhubungan dengan pendekatan ini.

1. Identifikasi operasi dominan (yang menyebabkan biaya), yaitu operasi yang paling sering terjadi (hingga faktor konstan). Dalam contoh Bubblesort, satu pilihan yang mungkin adalah perbandingan di baris 5.

   Sebagai alternatif, ikat semua konstanta untuk operasi elementer dengan resp maksimum (dari atas). minimum mereka (dari bawah) dan melakukan analisis biasa.

2. Lakukan analisis menggunakan jumlah eksekusi operasi ini sebagai biaya.
3. Saat menyederhanakan, izinkan estimasi. Berhati-hatilah untuk hanya mengizinkan estimasi dari atas jika sasaran Anda adalah resp batas atas ( ). dari bawah jika Anda ingin batas bawah ( ).$O$$\Omega$

Pastikan Anda memahami arti simbol Landau . Ingatlah bahwa batasan seperti itu ada untuk ketiga kasus ; menggunakan tidak berarti analisis kasus terburuk.$O$

Bacaan lebih lanjut

Ada banyak tantangan dan trik dalam analisis algoritma. Berikut ini beberapa bacaan yang disarankan.

• Bagaimana cara menghasilkan runtime algoritma?
  Bagaimana cara menggambarkan algoritma, membuktikan dan menganalisisnya?
• Mengapa menggunakan perbandingan alih-alih runtime untuk membandingkan dua algoritma?
  Bagaimana kita dapat mengasumsikan bahwa operasi dasar pada angka membutuhkan waktu yang konstan?
  Apa yang merupakan satu unit waktu dalam analisis runtime?
• Memecahkan atau memperkirakan hubungan perulangan untuk urutan angka
• Dasar-Dasar Analisis Amortisasi

Ada banyak pertanyaan yang ditandai dengan analisis-algoritma yang menggunakan teknik yang mirip dengan ini.

Hitungan Pernyataan Eksekusi

Ada metode lain, yang diperjuangkan oleh Donald E. Knuth dalam seri The Art of Computer Programming . Berbeda dengan menerjemahkan seluruh algoritma ke dalam satu rumus , ia bekerja secara independen dari semantik kode pada sisi "menyatukan semuanya" dan memungkinkan untuk naik ke level yang lebih rendah hanya jika diperlukan, mulai dari tampilan "mata elang". Setiap pernyataan dapat dianalisis secara terpisah dari yang lainnya, yang mengarah pada perhitungan yang lebih jelas. Namun, teknik ini cocok untuk kode yang agak rinci, bukan kode pseudo tingkat yang lebih tinggi.

Metode

Ini pada prinsipnya cukup sederhana:

1. Tetapkan setiap pernyataan nama / nomor.
2. Tetapkan setiap pernyataan beberapa biaya .$S_i$$C_i$
3. Tentukan untuk setiap pernyataan jumlah eksekusi .$S_i$$e_i$

4. Hitung total biaya

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

Anda dapat memasukkan taksiran dan / atau jumlah simbolis pada titik mana saja, melemahkan resp. generalisasi hasilnya sesuai.

Ketahuilah bahwa langkah 3 bisa sangat rumit. Biasanya ada di sana Anda harus bekerja dengan perkiraan (asimptotik) seperti " " untuk mendapatkan hasil.$e_{77} \in O(n \log n)$

Contoh: Pencarian mendalam-pertama

Pertimbangkan algoritma grafik-traversal berikut:

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

Kami berasumsi bahwa grafik (tidak terarah) diberikan oleh daftar adjacency pada node . Biarkan menjadi jumlah tepi.$\{0,\dots,n-1\}$$m$

Hanya dengan melihat algoritma, kita melihat bahwa beberapa pernyataan dieksekusi sama seringnya dengan yang lain. Kami memperkenalkan beberapa placeholder , dan untuk jumlah eksekusi :$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}$

Secara khusus, karena setiap panggilan rekursif di jalur 8 menyebabkan panggilan di saluran 3 (dan satu disebabkan oleh panggilan asli dari ). Selanjutnya, karena kondisi harus diperiksa sekali per iterasi tetapi kemudian sekali lagi untuk meninggalkannya.$e_8 = e_3-1$foodfs$e_6 = e_5 + e_7$while

Jelas bahwa . Sekarang, selama pembuktian kebenaran kami akan menunjukkan bahwa dijalankan tepat satu kali per node; yaitu, . Tapi kemudian, kita mengulangi setiap daftar adjacency tepat sekali dan setiap tepi menyiratkan dua entri secara total (satu untuk setiap node insiden); kita mendapatkan iterasi secara total. Menggunakan ini, kami memperoleh tabel berikut:$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}$

Ini membawa kita ke total biaya persis

$\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*}$

Dengan membuat instance nilai yang sesuai untuk kita dapat memperoleh lebih banyak biaya konkret. Misalnya, jika kita ingin menghitung akses memori (per kata), kami akan gunakan$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}$

dan dapatkan

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

Bacaan lebih lanjut

Lihat di bagian bawah jawaban saya yang lain .

Analisis algoritma, seperti pembuktian teorema, sebagian besar adalah seni (misalnya ada program sederhana (seperti masalah Collatz ) yang tidak kita ketahui cara menganalisisnya). Kita dapat mengonversi masalah kompleksitas algoritme menjadi masalah matematis, seperti yang dijawab secara komprehensif oleh Raphael , tetapi kemudian untuk menyatakan batasan biaya algoritma dalam hal fungsi yang diketahui, kita harus:

1. Gunakan teknik yang kita ketahui dari analisis yang ada, seperti menemukan batasan berdasarkan rekurensi yang kita pahami atau jumlah / integral yang dapat kita hitung.
2. Ubah algoritme menjadi sesuatu yang kita tahu cara menganalisis.
3. Datang dengan pendekatan yang sama sekali baru.