BAHAN KULIAH KE-10: ALGORITMA

Membagi dan menaklukkan

Ini adalah metode perancangan algoritma yang (secara informal) hasilkan sebagai
berikut:
Mengingat sebuah instance dari masalah yang harus dipecahkan, membagi ini
menjadi beberapa,
lebih kecil, sub-instances ( dari masalah yang sama ) secara independen
menyelesaikan masing-masing
sub-contoh dan kemudian menggabungkan solusi sub-contoh sehingga
menghasilkan a
solusi untuk contoh asli. Deskripsi ini menimbulkan pertanyaan:
Dengan metode apa sub-contoh dipecahkan secara terpisah ?
Jawaban atas pertanyaan ini sangat penting bagi konsep Divide- & amp-
Algoritma Conquer dan merupakan faktor kunci dalam mengukur efisiensinya.
Pertimbangkan hal berikut: Kami memiliki algoritma, alpha say, yang diketahui
selesaikan semua contoh masalah ukuran n paling banyak pada langkah 2 (di
mana c adalah beberapa
konstan). Kami kemudian menemukan sebuah algoritma, beta mengatakan, yang
memecahkan hal yang sama
masalah dengan:

Membagi sebuah instance menjadi 3 sub-instance dari ukuran n / 2 .

Selesaikan 3 sub-contoh ini.

Menggabungkan tiga sub-solusi mengambil langkah-langkah dn untuk melakukan

hal ini.
Misalkan algoritma asli kita, alpha , digunakan untuk melakukan `solves ini
sub-contoh 'langkah 2. Biarkan
T (alfa) (n) = Waktu berjalan alfa
T (beta) (n) = Waktu berjalan beta
Kemudian,
T (alfa) (n) = cn ^ 2 (menurut definisi alfa)
Tapi
T (beta) (n) = 3 T (alfa) (n / 2) + dn

Halaman 2
= (3/4) (cn ^ 2) + dn
Jadi jika dn <(cn ^ 2) / 4 (yaitu d <cn / 4 ) maka beta lebih cepat dari alpha
Khusus untuk semua n cukup besar , ( n> 4d / c = Konstan ), beta lebih cepat dari
alfa
Realisasi beta ini meningkat dengan alpha hanya dengan faktor konstan. Tapi jika
Ukuran masalah, n , cukup besar saat itu
n> 4d / c
n / 2> 4d / c
...
n / 2 ^ i> 4d / c
yang menunjukkan bahwa menggunakan beta dan bukan alpha untuk tahap
` solves this '
berulang kali sampai sub-sub-sub .. contohnya berukuran n0 <= (4d / c) akan
menghasilkan algoritma yang lebih cepat.
Jadi pertimbangkan algoritma baru berikut untuk contoh ukuran n
Prosedur gamma ( n : ukuran masalah ) adalah
mulai
jika n <= n ^ -0 maka
Selesaikan masalah dengan menggunakan Algorithm alpha ;
lain
Split menjadi 3 sub-contoh ukuran n / 2 ;
Gunakan gamma untuk memecahkan setiap sub-instance;
Kombinasikan 3 sub-solusi;
akhir jika ;
akhir gamma ;
Misalkan T (gamma) (n) menunjukkan waktu berjalan dari algoritma ini.
cn ^ 2
jika n <= n0
T (gamma) (n) =
3T (gamma) (n / 2) + dn sebaliknya

Halaman 3
Kita akan menunjukkan bagaimana hubungan bentuk ini dapat diperkirakan
kemudian di
Tentu saja. Dengan metode ini bisa ditunjukkan itu
T (gamma) (n) = O (n ^ {log3}) (= O (n ^ {1.59 ..})
Ini adalah perbaikan asimtotik pada algoritma alpha dan beta .
Perbaikan yang dihasilkan dari penerapan algoritma gamma adalah karena
Fakta bahwa hal itu memaksimalkan penghematan beta yang diraih .
Metode alpha yang relatif tidak efisien diterapkan hanya pada masalah "kecil"
ukuran.
Bentuk algoritma divide-and-conquer yang tepat ditandai dengan:

Ukuran input ambang batas, n0, di bawah ini yang masalah ukuran tidak sub-
terbagi.

Ukuran sub-contoh dimana sebuah contoh dibagi.

Jumlah sub-kasus tersebut.

Algoritma yang digunakan untuk menggabungkan sub-solusi.

Pada (II) lebih biasa untuk mempertimbangkan rasio ukuran masalah awal
terhadap sub-
ukuran contoh Dalam contoh kita ini adalah 2 . Ambang batas di (I) kadang-
kadang
disebut nilai dasar (rekursif) . Singkatnya, bentuk generik pembagian-
dan-menaklukkan algoritma adalah:
Prosedur D-dan-C ( n : ukuran input ) adalah
mulai
jika n <= n0 maka
Selesaikan masalah tanpa lebih jauh
bagian;
lain
Pisahkan ke r sub-instance
setiap ukuran n / k ;
untuk masing-masing r sub-contoh lakukan
D-dan-C (n / k) ;
Kombinasikan r yang dihasilkan
sub-solusi untuk diproduksi
solusi untuk masalah aslinya;

Halaman 4
akhir jika ;
akhir D-dan-C ;
Algoritma semacam itu secara alami dan mudah direalisasikan sebagai:
Prosedur rekursif
dalam (cocok) bahasa pemrograman tingkat tinggi.
Contoh 1:
Pencarian Biner
Pertimbangkan masalah berikut: satu memiliki direktori yang berisi satu set
nama dan nomor telepon yang terkait dengan masing-masing nama.
Direktori diurutkan menurut urutan alfabet nama. Ini berisi n entri
yang disimpan dalam 2 array:
nama (1..n) ; angka (1..n)
Dengan diberi nama dan nilai n masalahnya adalah menemukan nomor
yang terkait
dengan namanya
Kami berasumsi bahwa nama masukan yang diberikan sebenarnya terjadi di
direktori,
agar eksposisi lebih mudah.
Algoritma Divide- & amp-Conquer untuk memecahkan masalah ini adalah yang
paling sederhana
contoh paradigma
Hal ini berdasarkan pengamatan berikut
Dengan diberi nama, X mengatakan,
X terjadi di tempat tengah deret nama
Atau
X terjadi pada paruh pertama dari deret nama . (U)
Atau

Halaman 5
X terjadi pada paruh kedua dari deret nama . (L)
U (masing-masing L ) benar hanya jika X datang sebelumnya (masing-
masing setelah ) itu
nama disimpan di tempat tengah
Pengamatan ini mengarah pada algoritma berikut:
pencarian fungsi ( X : nama ;
mulai,
selesai
:
bilangan bulat )
bilangan bulat kembali adalah
tengah : bilangan bulat ;
mulai
tengah : = (mulai + selesai) / 2 ;
jika nama (tengah) = x maka
nomor kembali (tengah) ;
elsif X & ltnames (tengah) lalu
pencarian kembali (X, start, middle-1) ;
lain - X & gtnames (tengah)
pencarian kembali (X, middle + 1, finish) ;
akhir jika ;
pencarian akhir ;
Latihan: Bagaimana seharusnya algoritma ini dimodifikasi untuk memenuhi
kemungkinan itu
bahwa nama yang diberikan tidak terjadi di direktori? Dalam hal generik
bentuk algoritma pembagian & amplitudo, pada tahap mana ini
modifikasi dibuat
Kami menunda analisis kinerja algoritma sampai nanti.
Contoh 2
Pasangan terdekat
Memasukkan:
P = {p (1), p (2), ..., p (n)}
dimana p (i) = (x (i), y (i)) .
Satu set n poin di pesawat.

Halaman 6
Keluaran
Jarak antara dua titik yang paling dekat.
Catatan: Jarak DELTA (i, j) antara p (i) dan p (j) didefinisikan oleh
ekspresi:
Akar kuadrat dari {(x (i) -x (j)) ^ 2 + (y (i) -y (j)) ^ 2}
Kami menggambarkan algoritma membagi dan menaklukkan untuk masalah ini.
Kami berasumsi bahwa:
n adalah kekuatan pasti 2, n = 2 ^ k .
Untuk setiap i , x (i) <= x (i + 1) , yaitu titik-titiknya dipesan dengan
meningkatkan x dari
kiri ke kanan.
Pertimbangkan menggambar garis vertikal ( L ) melalui himpunan titik P sehingga
setengahnya
dari titik-titik di P berbohong ke kiri L dan setengah berbohong di sebelah
kanan L.

Halaman 7
Ada tiga kemungkinan:

Pasangan terdekat terletak pada P-KIRI .

Pasangan terdekat berbaring di P-RIGHT .

Pasangan terdekat berisi:

One Point dari P-KIRI
dan
Satu poin dari P-RIGHT
Jadi kita memiliki Metode Divide-and-Conquer (kasar) sebagai berikut:
fungsi terdekat_pair ( P : point set ; n : in
teger )
kembali mengambang adalah
DELTA-KIRI , DELTA-KANAN : mengapung ;
DELTA : mengapung ;
mulai
jika n = 2 maka

Halaman 8
jarak kembali dari p (1) sampai p (2) ;
lain
P-KIRI: = (p (1), p (2), ..., p (n / 2)) ;
P-RIGHT: = (p (n / 2 + 1), p (n / 2 + 2), ..., p (n)
);
DELTA-LEFT: = nextpair (P-KIRI, n / 2) ;
DELTA-RIGHT: = nextpair (P-RIGHT, n / 2
);
DELTA: = minimum (DELTA-LEFT, DELTA-RIGHT
);
-
*********************************************
Tentukan apakah ada titik p (l) di
P-KIRI dan p (r) di P-RIGHT dengan
jarak (p (l), p (r)) <DELTA . Jika ada
adalah poin seperti itu, atur DELTA menjadi
terkecil
jarak.
-
**********************************************
kembali DELTA ;
akhir jika ;
akhir terdekat_pair ;
Bagian antara dua baris komentar adalah tahap `kombinasi 'dari
Algoritma Divide-and-Conquer.
Jika ada titik p (l) dan p (r) yang jaraknya jauh lebih kecil dari DELTA
pasti begitu

X -coordinates dari p (l) dan p (r) berbeda dengan di kebanyakan DELTA.

The -coordinates y p (l) dan p (r) berbeda dengan di kebanyakan DELTA.

Halaman 9
Tahap gabungan dapat diimplementasikan dengan:

Menemukan semua titik di P-KIRI yang x- koordinasinya paling sedikit x (n / 2) -

DELTA .

Menemukan semua titik di P-RIGHT yang x- koordinasinya paling banyak

x (n / 2) + DELTA .
Panggil set titik yang ditemukan pada (1) dan (2) P-strip . dan mengurutkan s poin
di ini
dalam rangka meningkatkan y- koordinat. membiarkan (q (1), q (2), ..., q
(s)) menunjukkan
diurutkan titik.
Kemudian tahap penggabungan algoritma terdiri dari dua nested for loops:
untuk i di 1..s loop
untuk j di i + 1..s loop
keluar saat ( | x (i) - x (j) |> DELTA atau
| y (i) - y (j) | > DELTA );
jika jarak (q (i), q (j)) <DELTA lalu
DELTA: = jarak (q (i), q (j)) ;
akhir jika ;
lingkaran akhir ;
lingkaran akhir ;

Halaman 10
Contoh 3
Perkalian Integer
Divide-and-Conquer juga bisa diterapkan pada masalah selain itu
melibatkan pencarian Masalah berikut harus familiar:
The (2n) representasi desimal -digit produk x * y.
Catatan: Algoritma di bawah ini bekerja untuk setiap bilangan basis, misalnya
biner, desimal,
heksadesimal, dll. Kami menggunakan desimal hanya untuk kenyamanan.
Algoritma sekolah dasar klasik untuk perkalian membutuhkan O (n ^ 2)
Langkah untuk mengalikan dua nomor n -digit.
Sebuah langkah dianggap sebagai operasi tunggal yang melibatkan
dua digit angka tunggal ,
misalnya 5 + 6 , 3 * 4 , dll.
Pada tahun 1962, AA Karatsuba menemukan algoritma asimtotik lebih cepat untuk
mengalikan dua angka dengan menggunakan pendekatan membagi-dan-
menaklukkan.

Halaman 11

Halaman 12
Dari sini kita juga tahu bahwa hasil perkalian x dan y (yaitu z ) adalah

Halaman 13
Istilah (a * c) , (a * d) , (b * c) , dan (b * d) adalah setiap produk dari
2 (n / 2) -digit nomor.
Jadi ungkapan untuk perkalian x dan y dalam hal angka
a , b , c , dan d mengatakan bahwa:

Dua nomor satu digit bisa dikalikan dengan segera. (Rekursif

dasar: 1 langkah)

Jika n> 1 maka produk dari 2 n -digit nomor dapat dinyatakan dalam
syarat 4 produk dari 2 (n / 2) -digit nomor (Divide-and-Conquer
tahap)

Untuk menghitung hasil perkalian x dan y diberikan empat produk

Kembali hanya melibatkan penambahan (bisa dilakukan dengan langkah O (n) )
dan
mengalikan dengan kekuatan 10 (juga bisa dilakukan dalam O (n) langkah, karena
itu
hanya membutuhkan penempatan nomor 0s yang sesuai di akhir
jumlah). (Combine stage).
(1-3) oleh karena itu gambarkan algoritma Divide- & amp-Conquer untuk
mengalikan
dua nomor n -digit terwakili dalam desimal. Namun,
Cukup sulit: Berapa banyak langkah yang dilakukan algoritma yang dihasilkan
kalikan dua nomor n -digit?
Karatsuba menemukan bagaimana produk dari 2 n -digit nomor bisa
dinyatakan dalam tiga produk masing-masing 2 (n / 2) -digit nomor - sebagai
gantinya
dari empat produk yang merupakan implementasi naif dari Divide-and-Conquer
skema di atas menggunakan
Penghematan ini dilakukan dengan mengorbankan sedikit peningkatan jumlahnya
Langkah-langkah yang diambil di 'tahap menggabungkan' (Langkah 3) (meskipun,
ini akan tetap saja
gunakan operasi O (n) ).
Misalkan kita menghitung 3 produk berikut (dari 2 (n / 2) -digit nomor):

Halaman 14
fungsi Karatsuba
( xunder , yunder : n-digit
bilangan bulat ;
n : bilangan bulat )
kembali
(2n) -digit
bilangan bulat adalah
a , b , c , d : (n / 2) -digit integer
U , V , W : bilangan bulat n-digit ;
mulai
jika n = 1 maka
kembali x (0) * y (0) ;
lain
a: = x (n-1) ... x (n / 2) ;
b: = x (n / 2-1) ... x (0) ;
c: = y (n-1) ... y (n / 2) ;
d: = y (n / 2-1) ... y (0) ;
U: = Karatsuba (a, c, n / 2) ;
V: = Karatsuba (b, d, n / 2) ;
W: = Karatsuba (a + b, c + d, n / 2) ;
kembalikan U * 10 ^ n + (WUV) * 10 ^ n / 2 + V ;
akhir jika ;
akhiri Karatsuba ;
Analisis Kinerja
 Halaman 15
Telah diamati sebelumnya bahwa satu alasan untuk memeriksa paradigma
algoritmik
adalah fakta bahwa waktu berjalan mereka seringkali bisa ditentukan dengan tepat.
Hal ini berguna dalam memungkinkan perbandingan antara pertunjukan dua
algoritma yang akan dibuat
Untuk algoritma Divide-and-Conquer, waktu berjalan terutama dipengaruhi oleh 3
kriteria:

Jumlah sub-contoh (alpha) mana masalah dibagi.

Rasio ukuran masalah awal dengan ukuran sub-masalah. ( beta )

Jumlah langkah yang diperlukan untuk membagi contoh awal dan untuk
menggabungkan sub-solusi, dinyatakan sebagai fungsi dari ukuran input, n .
Misalkan, P , adalah algoritma divide-and-conquer yang menginstall alpha sub-
Contoh, masing-masing ukuran n / beta .
Misalkan Tp (n) menunjukkan jumlah langkah yang diambil oleh P pada contoh
ukuran n .
Kemudian
Tp (n0) = Konstan (basis rekursif)
Tp (n) = alpha Tp (n / beta) + gamma (n)
Dalam kasus ketika alpha dan beta sama-sama konstan (seperti pada semua contoh
kita
telah diberikan) ada metode umum yang bisa digunakan untuk mengatasinya
relasi rekuren agar mendapatkan arus asimtotik untuk berlari
waktu Tp (n) .
Secara umum:
T (n) = alpha T (n / beta) + O (n ^ gamma)
(dimana gamma konstan) memiliki solusinya
O (n ^ gamma)
jika alpha <
beta ^ gamma
T (n) = O (n ^ gamma log n)
jika alpha =
beta ^ gamma}
O (n ^ {log ^ -beta (alfa)) jika alpha>
beta ^ gamma