1. Pendahuluan, sekedar mengingatkan mengenai sejarah dan istilah, mengingat kembali berbagai teknik pemrograman, Dijelaskan pula mengenai materi kuliah,RPS, referensi, serta pre test untuk melihat sejauh mana pengetahuan mengenai algoritma.
2. Konsep algoritma, berisi konsep dasar algoritma, tahapan algoritma, menegaskan kembali ciri algoritma yang baik, menjelaskan strategi algoritma, serta mengulang kembali notasi matematik yang penting bagi perkuliahan ini.
3. Running Time, membahas mengenai efisiensi algoritma, serta melakukan pengukuran running time pada berbagai algoritma yang sederhana.
4. Faktor analisa algoritma, membahas running time dan penggunaan memory, kompleksitas waktu serta best, worst dan average case
5. Notasi Asymptotic, membahas Big Oh, Big Omega, Big Teta beserta sifat dan hubungannya.
6. Algoritma Rekursif, membahas algoritma rekursif dengan studi kasus menara hanoi dan faktorial beserta perhitungan kompleksitasnya, menyelesaikan relasi rekurens linier dan koefisien konstan, serta menyelesaikan relasi rekurens dengan teorema master
7. Brute Force. Membahas algoritma brute force dengan studi kasus menghitung an,faktorial, perkalian matriks, mencari faktor, mencari elemen terbesar/terkecil, sequential search, bubble sort, polinom, serta membahas karakteristik algoritma brute force.
8. Exhaustive search, membahas dengan berbagai studi kasus TSP, 1/0 knapsack, serangan pada kriptografi, serta solusi alternatif algoritma exhaustive search
9. Divide And Conquer, membahas algoritma divide and conquer dengan studi kasus minmax dan sorting (merge sort), serta menghitung kompleksitas waktunya.
10. Divide And Conquer (lanjutan), membahas studi kasus perpangkatan a serta perkalian matriks dengan algoritma strassen, dan menghitung kompleksitas waktunya
11. Algoritma greedy, membahas algoritma greedy dengan studi kasus penukaran uang, scheduling dan knapsack problem, beserta kompleksitas waktunya
12. Algoritma backtrack, membahas algoritma backtrack dengan studi kasus knapsack 0/1, persoalan n-ratu dan labirin, beserta kompleksitas waktunya
13. Dynamic programming , membahas pemrograman dinamis dengan studi kasus lintasan terpendek, capital budgetting dan knapsack 0/1, beserta kompleksitas waktunya
14. 14. Dynamic programming membahas pemrograman dinamis dengan studi kasus TSP beserta kompleksitas waktunya.

Analisa Algoritma

Pendahuluan

Konsep algoritma

Running time

Faktor analisa algoritma

Notasi asimptotik

Relasi Rekurens algoritma rekursif

Brute Force

Exhaustive Search

Devide & Conquer ( 2 pertemuan)

Algoritma Greedy

Algoritma Backtrack

Dynamic Programming

Matematika diskret

Pengantar mat diskret

Himpunan

Relasi (1 dan 2)

Fungsi

Pigeonhole Principle

Induksi matematika

Graph

Representasi graph

Aplikasi graph

Tree

Aplikasi tree

Otomata dan Pengantar Kompilasi

Pendahuluan

Konsep tatabahasa

Proses kompilasi

Otomata

Ekuivalensi NFA DFA

Ekspresi reguler

Analisa leksikal

Tatabahasa bebas konteks

Penyederhanaan tatabahasa bebas konteks

Analisa semantik dan kode antara

Optimasi kode

Penanganan kesalahan

Pembangkit kode

BINARY SEARCH

Salah satu penggunaan strategi penyelesaian menggunakan divide and conquer adalah dalam algoritma searching menggunakan binary search untuk suatu array yang telah terurut. Dengan menggunakan algoritma ini maka kompleksitas algoritma ini adalah O(log n). inilah algoritmanya :

int BinSearch (KeyType A [], int n, KeyType Key,int & Where)
// Search A [0 .. n-1] for Key. If found return
// TRUE and set Where to the subscript where found;
// otherwise, return FALSE . Assume A is in ascending
// sorted order and n > 0 .
{
int Lo = 0, Hi = n;
assert (n > 0);
while (Lo < Hi - 1)
{
Where = (Lo + Hi) / 2;
if (Key < A [Where])
Hi = Where;
else
Lo = Where;
}
Where = Lo;
return (Key == A [Lo]);
}

MERGE SORT

Inilah salah satu alternatif melakukan pengurutan /sorting menggunakan strategi divide and conquer. Kompleksitasnya algoritmanya dinyatakan dengan relasi rekurens T (n) = 2T (n/2) + n yang akan menghasilkan solusi O(n lg n)

MergeSort (TYPE A [], int n)
{
if (n > 1)
{
MergeSort (A, n/2);
MergeSort (A + n/2, n - n/2)
Merge (A, n/2, A + n/2, n - n/2, A)
}
}

Kelemahan merge sort ini adalah dibutuhkan memory ekstra pada saat fase Merge, bukan menggunakan teknik ‘in-place’.

PERKALIAN MATRIKS

Perkalian matriks yang biasa dilakukan, apabila dibuat prosedurnya secara biasa akan menghasilkan kompleksitas O(n^3). Hal tersebut dilakukan dengan menghitung masing masing elemen hasil perkalian matriks dengan rumus

C(i,j) = ? A(i,k) B(k,j)

Namun hal tersebut bisa dipangkas lagi menggunakan algoritma strassen, dimana setiap matriks dibagi menjadi 4 partisi, sebagai contoh sebuah matriks A dipartisi menjadi

A11 | A12
—————–
A21 | A22

dan dilakukan perhitungan sebagai berikut

M1 = (A11 + A22)(B11 + B22)

M2 = (A11 + A22)B11

M3 = A11(B11 ? B22)

M4 = A22(B21 ? B11)

M5 = (A11 + A12)B22

M6 = (A21 ? A11)(B11 + B12)

M7 = (A12 ? A22)(B21 + B22)

Diperoleh hasil perkalian matriks sebagai berikut:

C11 = M1 + M4 ? M5 + M7

C12 = M3 + M5

C21 = M2 + M4

C22 = M1 + M3 ? M2 + M6

Kompleksitas algoritmanya dapat dihitung dengan formulasi berikut

M (n) = 7M (n/2)

M (1) = 1;

Relasi rekurens tersebut akan menghasilkan solusi O(n ^ 2.807)