JAWABAN LATIHAN UJIAN TENGAH

BAGIKAN DAN TAKLUKKAN ALGORITMA

ALGORITMA PENURUNAN DAN PENAKLUKAN

NAMA GRUP
PEMBALAS

ANGGOTA
Nama1 (NIM)
Nama2 (NIM)
Nama3 (NIM)

DEPARTEMEN INFORMATIKA
FAKULTAS TEKNOLOGI INDUSTRI
UNIVERSITAS AHMAD DAHLAN

APRIL 2021
Petunjuk:
1. Lakukan tugas sebagai kelompok. Anggota maksimal grup adalah 3 siswa.
2. Tulis jawabannya di kotak jawaban. Anda dapat mengetik jawaban secara langsung
atau menggunakan jawaban tulisan tangan - pindai / tangkap - potong - sisipkan sebagai
gambar - masukkan ke dalam kotak jawaban.
3. Serahkan sebelum tenggat waktu. Jika Anda bekerja sebagai kelompok maka
perwakilan kelompok harus menyerahkan pekerjaan tersebut.
4. Tanyakan jika Anda memiliki pertanyaan.

Studi kasus
Hari ini, jembatan akan dibuka sehingga N
kapal bisa lewat di bawahnya. Namun karena
jembatan ini sudah cukup tua sehingga
proses untuk membuka jembatan akan
memakan waktu cukup lama. Semua kapal
yang ingin melewati jembatan perlu
menginformasikan ketinggiannya kepada
petugas jaga jembatan.

Pertanyaan
Bagilah dan Taklukkan Algoritma
1. Petugas jaga jembatan punya ide untuk membiarkan kapal lewat meski jembatan masih
belum dibuka sepenuhnya. Mereka memerintahkan kapal dengan ketinggian yang lebih
rendah untuk pergi terlebih dahulu kemudian diikuti oleh kapal yang lebih tinggi dan
seterusnya. Dengan cara ini selama proses pembukaan jembatan, kapal masih bisa
melewatinya dengan lancar. Tuliskan solusi untuk masalah ini menggunakan algoritma
divide and conquer. Tulis nama algoritma, notasi algoritma untuk menyelesaikan kasus
ini, dan analisa kompleksitas waktu dan notasi big-O!

Menjawab:
Nama algoritme:
Misalnya, Anda dapat menggunakan merge sort untuk mengurutkan kapal dalam urutan
menaik.
Asumsikan kapal memiliki atribut nama dan tinggi.

Notasi algoritma:
PROSEDUR MergeSort (INPUT / OUTPUT ship_data: array [1… N] kapal, index_left,
index_right: integer)

Deskripsi
JIKA index_left <index_right MAKA
index_middle ← (indeks_left + index_right) / 2

MergeSort (ship_data, index_left, index_middle)

MergeSort (ship_data, index_middle + 1, index_right)

Gabungkan (ship_data, index_left, index_middle, index_right)

BERAKHIR JIKA

PROSEDUR Gabungkan (INPUT / OUTPUT ship_data: array [1… N] dari kapal, index_left,
index_middle, index_right: integer)

Pernyataan
i, j, k, ndata_left, ndata_right: integer
data_left, data_right: susunan kapal

Deskripsi
ndata_left ← index_middle - index_left + 1
ndata_right ← index_right - index_middle
UNTUK i ← 0 UNTUK ndata_left LAKUKAN
data_left [i] ← data_kapal [index_left + i]
UNTUK i ← 0 UNTUK ndata_right LAKUKAN
data_right [i] ← data_kapal [index_middle + i + 1]

i ← 0, j ← 0, k ← index_left
WHILE (i <ndata_left AND j <ndata_right) DO
JIKA (data_left [i] .height <= data_right [j] .height) MAKA
data_kapal [k] ← data_left [i]
i←i+1
LAIN
data_kapal [k] ← data_right [j]
j←j+1
BERAKHIR JIKA
SELESAI

WHILE (i <ndata_left) LAKUKAN

data_kapal [k] ← data_left [i]
i←i+1
k←k+1
SELESAI
WHILE (j <ndata_right) DO
data_kapal [k] ← data_right [j]
j←j+1
 k←k+1
SELESAI

PROSEDUR Utama (INPUT: ship_data: array [1 ... N] kapal)

Deskripsi:
MergeSort (data_kapal, 0, N-1)
tulis (data_kapal)

Analisis kompleksitas waktu:

Asumsikan bahwa 𝑛 = 2 ^ 𝑘
Jadi T (n) adalah banyaknya operasi perbandingan pada proses sortir tiap bagian +
banyaknya perbandingan pada proses penggabungan
𝑇 (𝑛) adalah 𝑎 jika 𝑛 = 1 dan 2𝑇 (𝑛 / 2) + 𝑐𝑛 jika 𝑛> 1
𝑇 (𝑛) = 2𝑇 (𝑛 / 2) + 𝑐𝑛 = 2 (2𝑇 (𝑛 / 4) + 𝑐𝑛 / 2) + 𝑐𝑛
= 4𝑇 (𝑛 / 4) + 2𝑐𝑛 = 4 (2𝑇 (𝑛 / 8) + 𝑐𝑛 / 4) + 2𝑐𝑛
= 8𝑇 (𝑛 / 8) + 3𝑐𝑛 = 2 ^ 𝑘 𝑇 (𝑛 / 2 ^ 𝑘) + 𝑘𝑐𝑛
Jika pembagian bertahan hingga satu elemen tersisa maka 𝑛 / 2 ^ 𝑘 = 1 → 𝑘 = log (⁡𝑛)
Jadi 𝑇 (𝑛) = 𝑛𝑇 (1) + 𝑐𝑛 log (⁡𝑛) = 𝑛𝑎 + 𝑐𝑛 log (⁡𝑛)

Notasi Big-O:
Jadi 𝑇 (𝑛) = 𝑛𝑎 + 𝑐𝑛 log (⁡𝑛) = 𝑂 (𝑛 log (⁡𝑛))

Algoritma Penurunan dan Penaklukan

2. Petugas polisi menerima laporan bahwa sebuah kapal yang membawa barang curian
ingin menyeberangi jembatan. Petugas polisi mendapat informasi bahwa kapal yang
dicurigai memiliki tinggi X. Mereka mencari di antara N kapal yang telah disortir oleh
petugas penjaga jembatan pada masalah sebelumnya. Tuliskan solusi untuk masalah ini
menggunakan algoritma pengurangan dan taklukkan. Tulis nama algoritme, notasi
algoritme, dan analisis kompleksitas waktu dan notasi big-O untuk skenario kasus
terbaik dan kasus terburuk!

Jawab:
Nama algoritme:
Misalnya Anda dapat menggunakan pencarian biner untuk menemukan kapal X dalam array
kapal yang diurutkan
Asumsikan kapal memiliki atribut nama dan tinggi.

Notasi algoritma:
FUNGSI BinarySearch (INPUT ship_data: larik [1… N] kapal, X: kapal): integer

Pernyataan:
ditemukan_id: boolean
 index_low, index_high, index_mid: integer

Deskripsi:
is_found ← false
index_low ← 1
index_high ← N
WHILE (is_found = false AND index_low ≤ index_high) LAKUKAN
index_mid ← (index_low + index_high) / 2
JIKA (data_kapal [index_mid] .height = X.height) MAKA
is_found ← benar
JIKA LAINNYA (X.height <ship_data [index_mid)
index_high ← index_mid - 1
LAIN
index_low ← index_mid + 1
BERAKHIR JIKA
SELESAI
IF is_found = false MAKA KEMBALI -1
KEMBALI LAGI index_mid
BERAKHIR JIKA

PROSEDUR Utama (INPUT: ship_data: array [1 ... N] kapal, X: kapal)

Deskripsi:
MergeSort (data_kapal, 0, N-1)
index_ship ← BinarySearch (data_kapal, X)
JIKA index_ship> = 0 MAKA
tulis (ship_data [index_ship)
LAIN
tulis ("kapal tidak ditemukan")

Analisis kompleksitas waktu:

Kasus terbaik, jika nilai yang ingin kita temukan ada dalam a [𝑚𝑖𝑑] jadi 𝑇_𝑚𝑖𝑛 (𝑛) = 1
Kasus terburuk, jika nilainya tidak ditemukan atau ditemukan di akhir [𝑚𝑖𝑑]
𝑛𝑢𝑚 𝑠𝑡𝑒𝑝 = 𝑛 / 2 ^ 𝑘 = 1𝑛 = 2 ^ 𝑘 ⇒ log⁡(𝑛) = 𝑘 log (⁡2) ⇒ log⁡(𝑛) = 𝑘 kali

𝑇_𝑚𝑎𝑥 (𝑛) = log (𝑛)

Notasi Big-O:
Kasus terbaik, ketika T_min (n) = 1 = O (1)
Kasus terburuk, ketika T_max (n) = log (n)

Contoh:
Program Demo jika Anda ingin mencoba algoritma dengan beberapa contoh acak
#include <iostream>
#include <string>
#include <stdlib.h>
#include <time.h>

menggunakan namespace std;

class Ship {
pribadi:
nama string;
tinggi int;
publik:
Kapal();
Kapal (nama string, tinggi int);
string getName ();
int getHeight ();
};
Kapal :: Kapal () {}
Ship :: Ship (nama string, tinggi int) {
ini-> nama = nama;
ini-> tinggi = tinggi;
}
string Ship :: getName () {return this-> name; }
int Ship :: getHeight () {return this-> height; }

// bagi dan taklukkan - gabungkan sort

void Merge (Ship * listShip, int indexLeft, int indexMiddle, int indexRight) {
const int numDataLeft = indexMiddle - indexLeft + 1;
const int numDataRight = indexRight - indexMiddle;

Kapal * dataLeft = Kapal baru [numDataLeft];

Kapal * dataRight = Kapal baru [numDataRight];
untuk (int i = 0; i <numDataLeft; i ++)
dataLeft [i] = listShip [indexLeft + i];
untuk (int i = 0; i <numDataRight; i ++)
dataRight [i] = listShip [indexMiddle + i + 1];

int i = 0, j = 0, k = indexLeft;
while (i <numDataLeft && j <numDataRight) {
if (dataLeft [i] .getHeight () <= dataRight [j] .getHeight ()) {
listShip [k] = dataLeft [i];
i = i + 1;
}
lain {
listShip [k] = dataRight [j];
j = j + 1;
}
k = k + 1;
}
sementara (i <numDataLeft) {
 listShip [k] = dataLeft [i];
i = i + 1;
k = k + 1;
}
while (j <numDataRight) {
listShip [k] = dataRight [j];
j = j + 1;
k = k + 1;
}
}
void MergeSort (Ship * listShip, int indexLeft, int indexRight) {
if (indexLeft <indexRight) {
int indexMiddle = (indexLeft + indexRight) / 2;

MergeSort (listShip, indexLeft, indexMiddle);

MergeSort (listShip, indexMiddle + 1, indexRight);

Gabungkan (listShip, indexLeft, indexMiddle, indexRight);

}
}

// kurangi dan taklukkan - pencarian biner

int BinarySearch (Ship * listShip, Ship findThisShip, int N) {
int indexLow = 0, indexHigh = N, indexMiddle, indexResult = -1;
bool isFound = false;
while (! isFound && indexLow <= indexHigh) {
indexMiddle = (indexLow + indexHigh) / 2;
if (listShip [indexMiddle] .getHeight () == findThisShip.getHeight ()) {
indexResult = indexMiddle;
isFound = true;
}
else if (findThisShip.getHeight () <listShip [indexMiddle] .getHeight ()) {
indexHigh = indexMiddle - 1;
}
lain {
indexLow = indexMiddle + 1;
}
}
return indexResult;
}

int main (int argc, char ** argv) {

srand (waktu (NULL));
int N = 5;

// membuat N objek kapal secara acak dengan nama dan tinggi acak
Ship * listShip = Kapal baru [N];
cout << "Data Pengiriman Acak: \ n";
cout << "Indeks" << "\ t" << "Nama Kapal" << "\ t" << "Tinggi Kapal" << "\ n";
untuk (int i = 0; i <N-1; i ++) {
 string shipName = "Ship" + to_string (i + 1);
int shipHeight = rand ()% 20 + 5;
listShip [i] = Kapal (shipName, shipHeight);
cout << i << "\ t" << listShip [i] .getName () << "\ t \ t"
<< listShip [i] .getHeight () << "\ n";
}
listShip [N-1] = Kapal ("Ship5", 20);
cout << N-1 << "\ t" << listShip [N-1] .getName () << "\ t \ t"
<< listShip [N-1] .getHeight () << "\ n \ n";

// urutkan kapal berdasarkan ketinggian dalam urutan menaik menggunakan merge

sort
cout << "Bagi dan Taklukkan - Gabungkan Urutan \ n";
Ship * listDataShip = Kapal baru [N];
untuk (int i = 0; i <N; i ++)
listDataShip [i] = listShip [i];
MergeSort (listDataShip, 0, N-1);
cout << "Data Pengiriman yang Diurutkan: \ n";
cout << "Indeks" << "\ t" << "Nama Kapal" << "\ t" << "Tinggi Kapal" << "\ n";
untuk (int i = 0; i <N; i ++) {
cout << i << "\ t" << listDataShip [i] .getName () << "\ t \ t"
<< listDataShip [i] .getHeight () << "\ n";
}
cout << "\ n";

// misalnya cari kapal yang tingginya 20

Kapal findThisShip ("", 20);

cout << "Kurangi dan Taklukkan - Pencarian Biner \ n";

int indexShip = BinarySearch (listDataShip, findThisShip, N-1);
cout << "Nama kapal yang tingginya 20: \ n";
jika (indexShip> = 0) {
Kirim thisShip = listDataShip [indexShip];
cout << "Name \ t:" << thisShip.getName () << "\ n";
cout << "Height \ t:" << thisShip.getHeight () << "\ n \ n";
}
lain {
cout << "Tidak Ditemukan dalam daftar Kapal";
}
kembali 0;
}
Hasil