LAPORAN HASIL PROYEK

ALGORITMA KOMPUTER

DISUSUN OLEH :
Endro Swandi Nababan (5213230019)
Dito Yudisthira Nugroho (5213230021)
Fachmi Darizal Ananda (5213230004)
Josef Owen C D Siahaan (5213230003)
Raihan Novaldi Hsb (5213230005)

DOSEN PENGAMPU :
Dr. Amirhud Dalimunthe, S.T., M.Kom.
Reni Rahmadani, S.Kom., M.Kom.

PROGRAM STUDI S1 TEKNIK ELEKTRO

JURUSAN PENDIDIKAN TEKNIK ELEKTRO
FAKULTAS TEKNIK
UNIVERSITAS NEGERI MEDAN
2023
 METODOLOGI DAN HASIL PROYEK

A. Masalah yang dipilih pada

Penulis mengambil masalah 1 pada penugasan dosen pengampu matakuliah saat
pembagian tugas. Dimana masalah 1 mengacu pada pembuatan program yang menghasilkan
labirin secara acak dan memungkinkan pengguna menemukan jalur terpendek dari awal
ke akhir. Proyek ini akan melibatkan pembuatan labirin, representasi graf, dan
implementasi algoritma pencarian jalur.

B. Tujuan yang harus dicapai pada pengerjaan

1. Pembuatan Labirin: Implementasikan algoritma untuk menghasilkan labirin

secara acak. Anda bisa menggunakan algoritma seperti rekursif backtracking atau
algoritma Prim.
2. Representasi Graf: Gambarkan labirin sebagai graf di mana setiap sel adalah
node, dan terdapat edge antara sel yang bersebelahan. Graf ini akan digunakan
untuk pencarian jalur.
3. Algoritma Pencarian Jalur: Implementasikan algoritma pencarian seperti
Breadth-First Search (BFS), Dijkstra, atau yang lain. Biarkan pengguna memilih
algoritma yang ingin digunakan.
4. Visualisasi: Buat antarmuka grafis untuk menampilkan labirin dan proses
algoritma pencarian jalur yang dipilih. Pengguna harus dapat melihat bagaimana
algoritma menjelajahi labirin dan menemukan jalur optimal.

C. Langkah-langkah pengerjaan proyek

Adapun beberapa langkah-langkah yang memberikan panduan umum kepada penulis
untuk mengorganisir proyek antara lain sebagai berikut :
1. Pembuatan Labirin :
Implementasikan algoritma rekursif backtracking untuk menghasilkan labirin secara
acak. Pastikan labirin memiliki jalur yang dapat dijangkau dari awal ke akhir.

2. Representasi Graf:
Implementasikan representasi graf di mana setiap sel dalam labirin menjadi node.
Hubungkan node-node yang bersebelahan dengan edge untuk membentuk graf.

3. Algoritma Pencarian Jalur:

Implementasikan algoritma BFS untuk mencari jalur terpendek dari awal ke akhir.
Jangan lupa memasukkan logika untuk melibatkan representasi graf yang sudah
dibuat.

4. Membuat Visualisasi (Antarmuka Grafis):

Gunakan pustaka grafis seperti pygame atau tkinter untuk membuat antarmuka grafis.
Tampilkan labirin dan berikan representasi visual yang jelas. Implementasikan kontrol
agar pengguna dapat memilih algoritma pencarian dan melihat proses secara interaktif.
 5. Integrasi Seluruh Komponen:
Gabungkan seluruh komponen yang sudah dibuat menjadi satu program utuh. Pastikan
komunikasi yang baik antara pembuatan labirin, representasi graf, algoritma pencarian
jalur, dan visualisasi.

6. Testing dan Debugging:

Uji program secara menyeluruh dengan beberapa skenario. Identifikasi dan perbaiki
bug atau kesalahan yang mungkin muncul.

7. Dokumentasi:
Tulis dokumentasi yang menjelaskan cara menggunakan program, struktur kode, dan
logika di balik implementasi.
Setiap langkah yang tersebut membentuk bagian penting dari proyek ini dan saling
berkesinambungan. Berikut adalah hubungan antar langkah-langkah tersebut:

1. Pembuatan Labirin:
Langkah ini adalah langkah awal dan membentuk dasar untuk representasi graf.
Labirin yang dihasilkan oleh algoritma rekursif backtracking akan digunakan sebagai
struktur dasar yang akan diwakili oleh graf.

2. Representasi Graf:
Setelah labirin dihasilkan, selanjutnya adalah membuat representasi graf. Setiap sel
dalam labirin menjadi node dalam graf, dan edge dibentuk antara node-node yang
bersebelahan. Representasi graf ini diperlukan untuk implementasi algoritma
pencarian jalur.

3. Algoritma Pencarian Jalur:

Setelah graf terbentuk, langkah berikutnya adalah mengimplementasikan algoritma
pencarian jalur seperti BFS atau Dijkstra. Algoritma ini akan bekerja pada representasi
graf dan membantu menemukan jalur terpendek dari awal ke akhir.

4. Visualisasi:
Terakhir, visualisasi ditambahkan ke dalam proyek. Antarmuka grafis akan
menampilkan labirin, proses algoritma pencarian jalur, dan jalur terpendek yang
ditemukan. Visualisasi memungkinkan pengguna untuk melihat bagaimana algoritma
beroperasi dan bagaimana jalur terpendek ditemukan.

5. Integrasi Seluruh Komponen:

Setelah setiap komponen utama diimplementasikan, langkah ini melibatkan integrasi
semua komponen agar dapat berinteraksi satu sama lain. Misalnya, antarmuka grafis
dapat memanggil algoritma pencarian jalur dan memanipulasi labirin secara dinamis.

6. Testing dan Debugging:

 Setelah semua komponen terintegrasi, proyek perlu diuji secara menyeluruh untuk
memastikan bahwa semuanya berfungsi seperti yang diharapkan. Debugging
diperlukan untuk mengidentifikasi dan memperbaiki masalah atau kesalahan yang
mungkin muncul.

7. Dokumentasi:
Selama dan setelah implementasi, dokumentasi ditulis untuk menjelaskan cara
menggunakan program, struktur kode, dan logika di balik implementasi. Dokumentasi
pada pengerajaan proyek ini langsung penulis cantumkan secara berurutan pada
langkah-langkah.
Langkah-langkah ini membentuk alur kerja yang logis dan membantu memastikan
bahwa setiap elemen proyek berkontribusi secara langsung terhadap keseluruhan tujuan
proyek.
D. Media yang digunakan dalam pengerjaan proyek
Adapun proyek ini dikerjakan dengan menggunakan fitur Command Prompt pada
windows laptop penulis, sebagai tempat menjalankan perintah dan langkah-langkah yang
telah diperkenalkan tadi. Penulis menggunakan bahasa python dalam penerapan setiap
langkah-langkah yang dibicarakan diatas untuk pembuatan ini. Pada setiap langkah-langkah
diatas, penulis terus menggunakan bahasa python disetiap langkahnya, dan tidak hanya itu,
penulis juga selalu menggunakan fitur pygame di software python yang digunakan. Jadi,
apabila pembaca ingin menerapkan langkah-langkah dalam proyek ini untuk beberapa
keperluan, pembaca harus menginstal :

dan juga harus menginstal fitur pygame karena beberapa langkah yang dibahas akan
menggunakan fitur pygame dalam penerapannya. Sebelum menginstal fitur pygame ini, harus
diinstal terlebih dahulu aplikasi diatas. Berikut langkah untuk menginstal pygame pada
computer dengan menggunakan CMD :
1) Pastikan koneksi internet bagus.
2) Buka Command Prompt (cmd).
3) Jalankan perintah berikut untuk menginstal Pygame menggunakan pip :

4) Tunggu sampai penginstalannya selesai.

5) Jika sudah selesai, tampilan CMD akan tampak seperti gambar dibawah :

Pada saat penulis menerapkan setiap langkah yang membutuhkan fitur pygame, penulis
membutuhkan langkah-langkah berikut sebagai tahapan penggunaan fitur pygame dalam
penerapan skrip python :
1) Buat atau buka skrip Python yang menggunakan Pygame. Simpan dengan ekstensi
.py.
2) Buka Command Prompt di direktori tempat skrip Python disimpan.
3) Jalankan skrip Python dengan perintah berikut:

4) Gantilah nama_skrip.py dengan nama skrip Python Anda.

5) Program Pygame akan mulai berjalan dan jendela aplikasi akan muncul.

E. Penerapan setiap langkah-langkah pengerjaan proyek

1. Pembuatan Labirin
Implementasikan algoritma rekursif backtracking untuk menghasilkan labirin secara
acak. Pastikan labirin memiliki jalur yang dapat dijangkau dari awal ke akhir.
Berikut adalah contoh skript implementasi algoritma rekursif backtracking untuk
membuat labirin secara acak menggunakan Python :
import random
import pygame
import sys

# Inisialisasi Pygame
pygame.init()

# Dimensi layar
WIDTH, HEIGHT = 600, 600
# Warna
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
CELL_SIZE = 20

# Inisialisasi labirin
maze_rows = HEIGHT // CELL_SIZE
maze_cols = WIDTH // CELL_SIZE
maze = [[0] * maze_cols for _ in range(maze_rows)]

# Inisialisasi layar
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Maze Generator")

def draw_maze():
screen.fill(WHITE)
for row in range(maze_rows):
for col in range(maze_cols):
color = WHITE if maze[row][col] == 0 else BLACK
pygame.draw.rect(screen, color, (col * CELL_SIZE, row * CELL_SIZE,
CELL_SIZE, CELL_SIZE))
pygame.display.flip()

def recursive_backtracking(row, col):

directions = [(0, 2), (2, 0), (0, -2), (-2, 0)] # Move in increments of 2 to create walls
between paths
random.shuffle(directions)

for dr, dc in directions:

new_row, new_col = row + dr, col + dc
if 0 <= new_row < maze_rows and 0 <= new_col < maze_cols and
maze[new_row][new_col] == 0:
maze[new_row][new_col] = 1
maze[(row + new_row) // 2][(col + new_col) // 2] = 1 # Break the wall
between cells
recursive_backtracking(new_row, new_col)

# Generate maze using recursive backtracking

recursive_backtracking(0, 0)

# Draw the initial maze

draw_maze()

while True:
for event in pygame.event.get():
 if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
Hasil run script python dengan menggunakan CMD dapat dilihat sebagaimana digambarkan
oleh labirin berikut :

2. Representasi Graf
Setelah labirin dihasilkan, selanjutnya adalah membuat representasi graf. Setiap sel
dalam labirin menjadi node dalam graf, dan edge dibentuk antara node-node yang
bersebelahan. Representasi graf ini diperlukan untuk implementasi algoritma
pencarian jalur. Berikut adalah script python membuat representasi graf dari labirin
yang dihasilkan :

# Import library yang diperlukan

import pygame
import sys
import random

# Inisialisasi Pygame
pygame.init()

# Dimensi layar
WIDTH, HEIGHT = 600, 600

# Warna
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
CELL_SIZE = 20
# Inisialisasi labirin
maze_rows = HEIGHT // CELL_SIZE
maze_cols = WIDTH // CELL_SIZE
maze = [[0] * maze_cols for _ in range(maze_rows)]

# Inisialisasi layar
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Maze Generator")

def draw_maze():
screen.fill(WHITE)
for row in range(maze_rows):
for col in range(maze_cols):
color = WHITE if maze[row][col] == 0 else BLACK
pygame.draw.rect(screen, color, (col * CELL_SIZE, row * CELL_SIZE,
CELL_SIZE, CELL_SIZE))
pygame.display.flip()

def recursive_backtracking(row, col):

directions = [(0, 2), (2, 0), (0, -2), (-2, 0)] # Move in increments of 2 to create walls
between paths
random.shuffle(directions)

for dr, dc in directions:

new_row, new_col = row + dr, col + dc
if 0 <= new_row < maze_rows and 0 <= new_col < maze_cols and
maze[new_row][new_col] == 0:
maze[new_row][new_col] = 1
maze[(row + new_row) // 2][(col + new_col) // 2] = 1 # Break the wall
between cells
recursive_backtracking(new_row, new_col)

# Generate maze using recursive backtracking

recursive_backtracking(0, 0)

# Draw the initial maze

draw_maze()

# Inisialisasi objek graf

maze_graph = {}

# Fungsi untuk menambahkan edge antara node-node yang bersebelahan

def add_edges_from_maze(maze, maze_graph):
rows = len(maze)
cols = len(maze[0])
 for row in range(rows):
for col in range(cols):
if maze[row][col] == 0: # Hanya tambahkan edge untuk sel yang merupakan
jalur
maze_graph[(row, col)] = []

# Cek atas
if row > 0 and maze[row - 1][col] == 0:
maze_graph[(row, col)].append((row - 1, col))

# Cek bawah
if row < rows - 1 and maze[row + 1][col] == 0:
maze_graph[(row, col)].append((row + 1, col))

# Cek kiri
if col > 0 and maze[row][col - 1] == 0:
maze_graph[(row, col)].append((row, col - 1))

# Cek kanan
if col < cols - 1 and maze[row][col + 1] == 0:
maze_graph[(row, col)].append((row, col + 1))

# Menambahkan edge dari labirin ke graf

add_edges_from_maze(maze, maze_graph)

# Gunakan maze_graph seperti yang diinginkan.

print("Representasi Graf dari Labirin:")
print(maze_graph)
berikut adalah graft hasil dari script yang diberikan :
{(0, 11): [(1, 11)], (0, 29): [(1, 29)], (1, 1): [(1, 2)], (1, 2): [(1, 1), (1, 3)], (1, 3): [(2, 3), (1, 2),
(1, 4)], (1, 4): [(1, 3), (1, 5)], (1, 5): [(1, 4), (1, 6)], (1, 6): [(1, 5), (1, 7)], (1, 7): [(1, 6), (1, 8)],
(1, 8): [(1, 7), (1, 9)], (1, 9): [(2, 9), (1, 8)], (1, 11): [(0, 11), (1, 12)], (1, 12): [(1, 11), (1, 13)],
(1, 13): [(2, 13), (1, 12)], (1, 15): [(2, 15), (1, 16)], (1, 16): [(1, 15), (1, 17)], (1, 17): [(1, 16),
(1, 18)], (1, 18): [(1, 17), (1, 19)], (1, 19): [(1, 18), (1, 20)], (1, 20): [(1, 19), (1, 21)], (1, 21):
[(2, 21), (1, 20)], (1, 23): [(1, 24)], (1, 24): [(1, 23), (1, 25)], (1, 25): [(2, 25), (1, 24), (1, 26)],
(1, 26): [(1, 25), (1, 27)], (1, 27): [(1, 26)], (1, 29): [(0, 29), (2, 29)], (2, 3): [(1, 3), (3, 3)], (2,
9): [(1, 9), (3, 9)], (2, 13): [(1, 13), (3, 13)], (2, 15): [(1, 15), (3, 15)], (2, 21): [(1, 21), (3, 21)],
(2, 25): [(1, 25), (3, 25)], (2, 29): [(1, 29), (3, 29)], (3, 1): [(4, 1), (3, 2)], (3, 2): [(3, 1), (3, 3)],
(3, 3): [(2, 3), (3, 2)], (3, 5): [(4, 5)], (3, 7): [(3, 8)], (3, 8): [(3, 7), (3, 9)], (3, 9): [(2, 9), (3, 8),
(3, 10)], (3, 10): [(3, 9), (3, 11)], (3, 11): [(4, 11), (3, 10)], (3, 13): [(2, 13), (3, 14)], (3, 14):
[(3, 13), (3, 15)], (3, 15): [(2, 15), (3, 14)], (3, 17): [(4, 17), (3, 18)], (3, 18): [(3, 17), (3, 19)],
(3, 19): [(4, 19), (3, 18)], (3, 21): [(2, 21), (4, 21), (3, 22)], (3, 22): [(3, 21), (3, 23)], (3, 23):
[(3, 22)], (3, 25): [(2, 25), (4, 25)], (3, 27): [(4, 27)], (3, 29): [(2, 29), (4, 29)], (4, 1): [(3, 1),
(5, 1)], (4, 5): [(3, 5), (5, 5)], (4, 11): [(3, 11), (5, 11)], (4, 17): [(3, 17), (5, 17)], (4, 19): [(3,
19), (5, 19)], (4, 21): [(3, 21), (5, 21)], (4, 25): [(3, 25), (5, 25)], (4, 27): [(3, 27), (5, 27)], (4,
29): [(3, 29), (5, 29)], (5, 1): [(4, 1), (6, 1)], (5, 3): [(5, 4)], (5, 4): [(5, 3), (5, 5)], (5, 5): [(4, 5),
(6, 5), (5, 4), (5, 6)], (5, 6): [(5, 5), (5, 7)], (5, 7): [(5, 6), (5, 8)], (5, 8): [(5, 7), (5, 9)], (5, 9):
[(6, 9), (5, 8)], (5, 11): [(4, 11), (6, 11), (5, 12)], (5, 12): [(5, 11), (5, 13)], (5, 13): [(5, 12), (5,
14)], (5, 14): [(5, 13), (5, 15)], (5, 15): [(5, 14), (5, 16)], (5, 16): [(5, 15), (5, 17)], (5, 17): [(4,
17), (5, 16)], (5, 19): [(4, 19), (6, 19)], (5, 21): [(4, 21), (6, 21)], (5, 23): [(6, 23), (5, 24)], (5,
24): [(5, 23), (5, 25)], (5, 25): [(4, 25), (5, 24)], (5, 27): [(4, 27), (6, 27)], (5, 29): [(4, 29), (6,
29)], (6, 1): [(5, 1), (7, 1)], (6, 5): [(5, 5), (7, 5)], (6, 9): [(5, 9), (7, 9)], (6, 11): [(5, 11), (7,
11)], (6, 19): [(5, 19), (7, 19)], (6, 21): [(5, 21), (7, 21)], (6, 23): [(5, 23), (7, 23)], (6, 27): [(5,
27), (7, 27)], (6, 29): [(5, 29), (7, 29)], (7, 1): [(6, 1), (7, 2)], (7, 2): [(7, 1), (7, 3)], (7, 3): [(8,
3), (7, 2)], (7, 5): [(6, 5), (7, 6)], (7, 6): [(7, 5), (7, 7)], (7, 7): [(8, 7), (7, 6)], (7, 9): [(6, 9), (8,
9)], (7, 11): [(6, 11)], (7, 13): [(7, 14)], (7, 14): [(7, 13), (7, 15)], (7, 15): [(8, 15), (7, 14)], (7,
17): [(7, 18)], (7, 18): [(7, 17), (7, 19)], (7, 19): [(6, 19), (8, 19), (7, 18)], (7, 21): [(6, 21), (7,
22)], (7, 22): [(7, 21), (7, 23)], (7, 23): [(6, 23), (8, 23), (7, 22)], (7, 25): [(8, 25), (7, 26)], (7,
26): [(7, 25), (7, 27)], (7, 27): [(6, 27), (7, 26)], (7, 29): [(6, 29), (8, 29)], (8, 3): [(7, 3), (9, 3)],
(8, 7): [(7, 7), (9, 7)], (8, 9): [(7, 9), (9, 9)], (8, 15): [(7, 15), (9, 15)], (8, 19): [(7, 19), (9, 19)],
(8, 23): [(7, 23), (9, 23)], (8, 25): [(7, 25), (9, 25)], (8, 29): [(7, 29), (9, 29)], (9, 0): [(9, 1)], (9,
1): [(9, 0)], (9, 3): [(8, 3), (9, 4)], (9, 4): [(9, 3), (9, 5)], (9, 5): [(10, 5), (9, 4)], (9, 7): [(8, 7),
(10, 7)], (9, 9): [(8, 9), (9, 10)], (9, 10): [(9, 9), (9, 11)], (9, 11): [(10, 11), (9, 10), (9, 12)], (9,
12): [(9, 11), (9, 13)], (9, 13): [(9, 12), (9, 14)], (9, 14): [(9, 13), (9, 15)], (9, 15): [(8, 15), (10,
15), (9, 14), (9, 16)], (9, 16): [(9, 15), (9, 17)], (9, 17): [(9, 16)], (9, 19): [(8, 19), (9, 20)], (9,
20): [(9, 19), (9, 21)], (9, 21): [(10, 21), (9, 20)], (9, 23): [(8, 23), (10, 23)], (9, 25): [(8, 25),
(9, 26)], (9, 26): [(9, 25), (9, 27)], (9, 27): [(9, 26), (9, 28)], (9, 28): [(9, 27), (9, 29)], (9, 29):
[(8, 29), (10, 29), (9, 28)], (10, 5): [(9, 5), (11, 5)], (10, 7): [(9, 7), (11, 7)], (10, 11): [(9, 11),
(11, 11)], (10, 15): [(9, 15), (11, 15)], (10, 21): [(9, 21), (11, 21)], (10, 23): [(9, 23), (11, 23)],
(10, 29): [(9, 29), (11, 29)], (11, 1): [(12, 1), (11, 2)], (11, 2): [(11, 1), (11, 3)], (11, 3): [(11,
2)], (11, 5): [(10, 5), (12, 5)], (11, 7): [(10, 7), (12, 7)], (11, 9): [(12, 9)], (11, 11): [(10, 11),
(12, 11)], (11, 13): [(12, 13)], (11, 15): [(10, 15)], (11, 17): [(12, 17), (11, 18)], (11, 18): [(11,
17), (11, 19)], (11, 19): [(11, 18), (11, 20)], (11, 20): [(11, 19), (11, 21)], (11, 21): [(10, 21),
(12, 21), (11, 20)], (11, 23): [(10, 23), (11, 24)], (11, 24): [(11, 23), (11, 25)], (11, 25): [(11,
24), (11, 26)], (11, 26): [(11, 25), (11, 27)], (11, 27): [(11, 26)], (11, 29): [(10, 29), (12, 29)],
(12, 1): [(11, 1), (13, 1)], (12, 5): [(11, 5), (13, 5)], (12, 7): [(11, 7), (13, 7)], (12, 9): [(11, 9),
(13, 9)], (12, 11): [(11, 11), (13, 11)], (12, 13): [(11, 13), (13, 13)], (12, 17): [(11, 17), (13,
17)], (12, 21): [(11, 21), (13, 21)], (12, 29): [(11, 29), (13, 29)], (13, 1): [(12, 1), (14, 1), (13,
2)], (13, 2): [(13, 1), (13, 3)], (13, 3): [(13, 2), (13, 4)], (13, 4): [(13, 3), (13, 5)], (13, 5): [(12,
5), (14, 5), (13, 4)], (13, 7): [(12, 7), (13, 8)], (13, 8): [(13, 7), (13, 9)], (13, 9): [(12, 9), (13,
8)], (13, 11): [(12, 11), (14, 11)], (13, 13): [(12, 13), (13, 14)], (13, 14): [(13, 13), (13, 15)],
(13, 15): [(13, 14), (13, 16)], (13, 16): [(13, 15), (13, 17)], (13, 17): [(12, 17), (14, 17), (13,
16)], (13, 19): [(14, 19)], (13, 21): [(12, 21), (13, 22)], (13, 22): [(13, 21), (13, 23)], (13, 23):
[(13, 22), (13, 24)], (13, 24): [(13, 23), (13, 25)], (13, 25): [(13, 24), (13, 26)], (13, 26): [(13,
25), (13, 27)], (13, 27): [(13, 26)], (13, 29): [(12, 29), (14, 29)], (14, 1): [(13, 1), (15, 1)], (14,
5): [(13, 5), (15, 5)], (14, 11): [(13, 11), (15, 11)], (14, 17): [(13, 17), (15, 17)], (14, 19): [(13,
19), (15, 19)], (14, 29): [(13, 29), (15, 29)], (15, 1): [(14, 1)], (15, 3): [(16, 3)], (15, 5): [(14,
5), (15, 6)], (15, 6): [(15, 5), (15, 7)], (15, 7): [(15, 6), (15, 8)], (15, 8): [(15, 7), (15, 9)], (15,
9): [(15, 8)], (15, 11): [(14, 11), (16, 11), (15, 12)], (15, 12): [(15, 11), (15, 13)], (15, 13):
[(15, 12), (15, 14)], (15, 14): [(15, 13), (15, 15)], (15, 15): [(16, 15), (15, 14)], (15, 17): [(14,
17)], (15, 19): [(14, 19), (16, 19), (15, 20)], (15, 20): [(15, 19), (15, 21)], (15, 21): [(15, 20),
(15, 22)], (15, 22): [(15, 21), (15, 23)], (15, 23): [(15, 22), (15, 24)], (15, 24): [(15, 23), (15,
25)], (15, 25): [(16, 25), (15, 24), (15, 26)], (15, 26): [(15, 25), (15, 27)], (15, 27): [(15, 26),
(15, 28)], (15, 28): [(15, 27), (15, 29)], (15, 29): [(14, 29), (16, 29), (15, 28)], (16, 3): [(15, 3),
(17, 3)], (16, 11): [(15, 11), (17, 11)], (16, 15): [(15, 15), (17, 15)], (16, 19): [(15, 19), (17,
19)], (16, 25): [(15, 25), (17, 25)], (16, 29): [(15, 29), (17, 29)], (17, 1): [(18, 1), (17, 2)], (17,
2): [(17, 1), (17, 3)], (17, 3): [(16, 3), (17, 2), (17, 4)], (17, 4): [(17, 3), (17, 5)], (17, 5): [(17,
4), (17, 6)], (17, 6): [(17, 5), (17, 7)], (17, 7): [(17, 6), (17, 8)], (17, 8): [(17, 7), (17, 9)], (17,
9): [(17, 8), (17, 10)], (17, 10): [(17, 9), (17, 11)], (17, 11): [(16, 11), (17, 10), (17, 12)], (17,
12): [(17, 11), (17, 13)], (17, 13): [(17, 12)], (17, 15): [(16, 15), (17, 16)], (17, 16): [(17, 15),
(17, 17)], (17, 17): [(18, 17), (17, 16), (17, 18)], (17, 18): [(17, 17), (17, 19)], (17, 19): [(16,
19), (17, 18), (17, 20)], (17, 20): [(17, 19), (17, 21)], (17, 21): [(17, 20)], (17, 23): [(18, 23)],
(17, 25): [(16, 25), (17, 26)], (17, 26): [(17, 25), (17, 27)], (17, 27): [(18, 27), (17, 26)], (17,
29): [(16, 29), (18, 29)], (18, 1): [(17, 1), (19, 1)], (18, 17): [(17, 17), (19, 17)], (18, 23): [(17,
23), (19, 23)], (18, 27): [(17, 27), (19, 27)], (18, 29): [(17, 29), (19, 29)], (19, 1): [(18, 1), (19,
2)], (19, 2): [(19, 1), (19, 3)], (19, 3): [(19, 2), (19, 4)], (19, 4): [(19, 3), (19, 5)], (19, 5): [(19,
4)], (19, 7): [(20, 7), (19, 8)], (19, 8): [(19, 7), (19, 9)], (19, 9): [(19, 8), (19, 10)], (19, 10):
[(19, 9), (19, 11)], (19, 11): [(19, 10), (19, 12)], (19, 12): [(19, 11), (19, 13)], (19, 13): [(19,
12), (19, 14)], (19, 14): [(19, 13), (19, 15)], (19, 15): [(20, 15), (19, 14)], (19, 17): [(18, 17),
(19, 18)], (19, 18): [(19, 17), (19, 19)], (19, 19): [(20, 19), (19, 18)], (19, 21): [(19, 22)], (19,
22): [(19, 21), (19, 23)], (19, 23): [(18, 23), (20, 23), (19, 22), (19, 24)], (19, 24): [(19, 23),
(19, 25)], (19, 25): [(19, 24)], (19, 27): [(18, 27)], (19, 29): [(18, 29), (20, 29)], (20, 7): [(19,
7), (21, 7)], (20, 15): [(19, 15), (21, 15)], (20, 19): [(19, 19), (21, 19)], (20, 23): [(19, 23), (21,
23)], (20, 29): [(19, 29), (21, 29)], (21, 0): [(21, 1)], (21, 1): [(21, 0), (21, 2)], (21, 2): [(21, 1),
(21, 3)], (21, 3): [(21, 2), (21, 4)], (21, 4): [(21, 3), (21, 5)], (21, 5): [(21, 4), (21, 6)], (21, 6):
[(21, 5), (21, 7)], (21, 7): [(20, 7), (22, 7), (21, 6)], (21, 9): [(21, 10)], (21, 10): [(21, 9), (21,
11)], (21, 11): [(22, 11), (21, 10), (21, 12)], (21, 12): [(21, 11), (21, 13)], (21, 13): [(22, 13),
(21, 12)], (21, 15): [(20, 15), (21, 16)], (21, 16): [(21, 15), (21, 17)], (21, 17): [(22, 17), (21,
16)], (21, 19): [(20, 19), (22, 19)], (21, 21): [(22, 21)], (21, 23): [(20, 23), (21, 24)], (21, 24):
[(21, 23), (21, 25)], (21, 25): [(21, 24), (21, 26)], (21, 26): [(21, 25), (21, 27)], (21, 27): [(22,
27), (21, 26)], (21, 29): [(20, 29), (22, 29)], (22, 7): [(21, 7), (23, 7)], (22, 11): [(21, 11), (23,
11)], (22, 13): [(21, 13), (23, 13)], (22, 17): [(21, 17), (23, 17)], (22, 19): [(21, 19), (23, 19)],
(22, 21): [(21, 21), (23, 21)], (22, 27): [(21, 27), (23, 27)], (22, 29): [(21, 29), (23, 29)], (23,
1): [(23, 2)], (23, 2): [(23, 1), (23, 3)], (23, 3): [(24, 3), (23, 2)], (23, 5): [(23, 6)], (23, 6): [(23,
5), (23, 7)], (23, 7): [(22, 7), (23, 6)], (23, 9): [(24, 9)], (23, 11): [(22, 11), (24, 11)], (23, 13):
[(22, 13)], (23, 15): [(24, 15), (23, 16)], (23, 16): [(23, 15), (23, 17)], (23, 17): [(22, 17), (23,
16)], (23, 19): [(22, 19), (24, 19)], (23, 21): [(22, 21), (23, 22)], (23, 22): [(23, 21), (23, 23)],
(23, 23): [(23, 22), (23, 24)], (23, 24): [(23, 23), (23, 25)], (23, 25): [(24, 25), (23, 24)], (23,
27): [(22, 27), (23, 28)], (23, 28): [(23, 27), (23, 29)], (23, 29): [(22, 29), (24, 29), (23, 28)],
(24, 3): [(23, 3), (25, 3)], (24, 9): [(23, 9), (25, 9)], (24, 11): [(23, 11), (25, 11)], (24, 15): [(23,
15), (25, 15)], (24, 19): [(23, 19), (25, 19)], (24, 25): [(23, 25), (25, 25)], (24, 29): [(23, 29),
(25, 29)], (25, 0): [(25, 1)], (25, 1): [(26, 1), (25, 0)], (25, 3): [(24, 3), (25, 4)], (25, 4): [(25,
3), (25, 5)], (25, 5): [(25, 4), (25, 6)], (25, 6): [(25, 5), (25, 7)], (25, 7): [(26, 7), (25, 6), (25,
8)], (25, 8): [(25, 7), (25, 9)], (25, 9): [(24, 9), (26, 9), (25, 8)], (25, 11): [(24, 11), (25, 12)],
(25, 12): [(25, 11), (25, 13)], (25, 13): [(25, 12), (25, 14)], (25, 14): [(25, 13), (25, 15)], (25,
15): [(24, 15), (25, 14)], (25, 17): [(26, 17), (25, 18)], (25, 18): [(25, 17), (25, 19)], (25, 19):
[(24, 19), (25, 18), (25, 20)], (25, 20): [(25, 19), (25, 21)], (25, 21): [(25, 20), (25, 22)], (25,
22): [(25, 21), (25, 23)], (25, 23): [(26, 23), (25, 22)], (25, 25): [(24, 25), (25, 26)], (25, 26):
[(25, 25), (25, 27)], (25, 27): [(26, 27), (25, 26)], (25, 29): [(24, 29), (26, 29)], (26, 1): [(25,
1), (27, 1)], (26, 7): [(25, 7), (27, 7)], (26, 9): [(25, 9), (27, 9)], (26, 17): [(25, 17), (27, 17)],
(26, 23): [(25, 23), (27, 23)], (26, 27): [(25, 27), (27, 27)], (26, 29): [(25, 29), (27, 29)], (27,
1): [(26, 1), (27, 2)], (27, 2): [(27, 1), (27, 3)], (27, 3): [(27, 2), (27, 4)], (27, 4): [(27, 3), (27,
5)], (27, 5): [(27, 4)], (27, 7): [(26, 7)], (27, 9): [(26, 9), (27, 10)], (27, 10): [(27, 9), (27, 11)],
(27, 11): [(27, 10), (27, 12)], (27, 12): [(27, 11), (27, 13)], (27, 13): [(27, 12), (27, 14)], (27,
14): [(27, 13), (27, 15)], (27, 15): [(27, 14), (27, 16)], (27, 16): [(27, 15), (27, 17)], (27, 17):
[(26, 17), (27, 16)], (27, 19): [(28, 19), (27, 20)], (27, 20): [(27, 19), (27, 21)], (27, 21): [(27,
20)], (27, 23): [(26, 23), (27, 24)], (27, 24): [(27, 23), (27, 25)], (27, 25): [(27, 24), (27, 26)],
(27, 26): [(27, 25), (27, 27)], (27, 27): [(26, 27), (27, 26)], (27, 29): [(26, 29), (28, 29)], (28,
19): [(27, 19), (29, 19)], (28, 29): [(27, 29), (29, 29)], (29, 0): [(29, 1)], (29, 1): [(29, 0), (29,
2)], (29, 2): [(29, 1), (29, 3)], (29, 3): [(29, 2), (29, 4)], (29, 4): [(29, 3), (29, 5)], (29, 5): [(29,
4), (29, 6)], (29, 6): [(29, 5), (29, 7)], (29, 7): [(29, 6), (29, 8)], (29, 8): [(29, 7), (29, 9)], (29,
9): [(29, 8), (29, 10)], (29, 10): [(29, 9), (29, 11)], (29, 11): [(29, 10), (29, 12)], (29, 12): [(29,
11), (29, 13)], (29, 13): [(29, 12), (29, 14)], (29, 14): [(29, 13), (29, 15)], (29, 15): [(29, 14),
(29, 16)], (29, 16): [(29, 15), (29, 17)], (29, 17): [(29, 16), (29, 18)], (29, 18): [(29, 17), (29,
19)], (29, 19): [(28, 19), (29, 18), (29, 20)], (29, 20): [(29, 19), (29, 21)], (29, 21): [(29, 20),
(29, 22)], (29, 22): [(29, 21), (29, 23)], (29, 23): [(29, 22), (29, 24)], (29, 24): [(29, 23), (29,
25)], (29, 25): [(29, 24), (29, 26)], (29, 26): [(29, 25), (29, 27)], (29, 27): [(29, 26), (29, 28)],
(29, 28): [(29, 27), (29, 29)], (29, 29): [(28, 29), (29, 28)]}
Diatas merupakan graft hasil dari representasi Labirin menjadi bentuk graft. Data diatas yang
diberikan menggambarkan suatu graf dengan simpul dan sisi. Setiap simpul memiliki tetangga
atau sisi yang terhubung dengan simpul lain. Formatnya yakni {(simpul, sisi): [daftar
tetangga]}.
3. Implementasi Algoritma Pencarian Jalur
Setelah graf terbentuk, langkah berikutnya adalah mengimplementasikan algoritma
pencarian jalur seperti BFS atau Dijkstra. Algoritma ini akan bekerja pada representasi
graf dan membantu menemukan jalur terpendek dari awal ke akhir.

a. Algoritma Pencarian Jalur: Dijkstra

import heapq
def dijkstra(graph, start, end):
# Inisialisasi kamus untuk menyimpan jarak terpendek dari start ke setiap node
distances = {node: float('infinity') for node in graph}
distances[start] = 0

# Inisialisasi priority queue (heap) untuk menyimpan node-node yang akan

dieksplorasi
priority_queue = [(0, start)]
while priority_queue:
current_distance, current_node = heapq.heappop(priority_queue)
# Skip jika node ini sudah dieksplorasi sebelumnya
 if current_distance > distances[current_node]:
continue
for neighbor, weight in graph[current_node].items():
distance = current_distance + weight
# Perbarui jarak terpendek jika ditemukan jarak yang lebih pendek
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(priority_queue, (distance, neighbor))
# Jalur terpendek dari start ke end
path = []
current = end
while current != start:
path.insert(0, current)
current = min(graph[current], key=lambda x: distances[x])
path.insert(0, start)
return path, distances[end]
# Contoh penggunaan
graph = {
'A': {'B': 1, 'C': 4},
'B': {'A': 1, 'C': 2, 'D': 5},
'C': {'A': 4, 'B': 2, 'D': 1},
'D': {'B': 5, 'C': 1}
}
start_node = 'A'
end_node = 'D'
shortest_path, shortest_distance = dijkstra(graph, start_node, end_node)
print(f"Jalur terpendek dari {start_node} ke {end_node}: {shortest_path}")
print(f"Jarak terpendek: {shortest_distance}")

Hasil run program diatas dengan CMD ditunjukkan pada gambar berikut :
Script Python yang penulis jalankan dengan ekstensi ( dijkstraPencariJalur.py)
tampaknya berhasil menemukan jalur terpendek dari simpul A ke simpul D. Outputnya
menyatakan bahwa jalur terpendek adalah ['A', 'B', 'D'] dengan jarak terpendek sebesar 4.
Ini berarti, berdasarkan representasi graf yang telah Anda buat dan input yang diberikan ke
algoritma Dijkstra, jalur dari simpul A ke simpul D melalui simpul B memiliki panjang 4
(jumlah bobot/jarak minimum).
b. Algoritma Pencarian Jalur: Breadth-First Search (BFS)
from collections import defaultdict, deque
class Graf:
def __init__(self):
self.graph = defaultdict(list)
def tambah_edge(self, u, v):
self.graph[u].append(v)
self.graph[v].append(u)
def bfs(self, mulai, akhir):
visited = set()
queue = deque([[mulai]])
if mulai == akhir:
return f"Sudah berada di simpul akhir {akhir}"
while queue:
path = queue.popleft()
node = path[-1]
if node not in visited:
tetangga = self.graph[node]
for tetangga_node in tetangga:
new_path = list(path)
new_path.append(tetangga_node)
queue.append(new_path)
if tetangga_node == akhir:
 return f"Jalur terpendek: {new_path}"
visited.add(node)
return "Tidak ditemukan jalur antara kedua simpul"
# Contoh penggunaan
graf = Graf()
graf.tambah_edge('A', 'B')
graf.tambah_edge('B', 'C')
graf.tambah_edge('B', 'D')
graf.tambah_edge('C', 'D')
graf.tambah_edge('D', 'E')
simpul_mulai = 'A'
simpul_akhir = 'E'
hasil_bfs = graf.bfs(simpul_mulai, simpul_akhir)
print(hasil_bfs)
Hasil run program diatas dengan CMD ditunjukkan pada gambar berikut :

Script Python yang penulis jalankan dengan ekstensi

(BreadthFirstSearch_Algoritm_jalan_terpendek.py) tampaknya berhasil
menemukan jalur terpendek dari simpul A ke simpul E yaitu ['A', 'B', 'D', 'E'].
Artinya adalah bahwa jalur terpendek dari simpul 'A' ke simpul 'E' dalam graf yang
didefinisikan adalah ['A', 'B', 'D', 'E']. Setiap elemen dalam daftar tersebut mewakili simpul
yang harus dilalui dari awal hingga akhir. Sebagai contoh, Anda mulai dari simpul 'A',
kemudian ke simpul 'B', kemudian ke simpul 'D', dan akhirnya sampai ke simpul 'E'.
Jarak atau bobot jalur tergantung pada representasi graf dan jenis graf yang digunakan.
Dalam contoh ini, graf yang digunakan tidak memiliki bobot, dan jalur terpendek diukur
dengan jumlah simpul yang dilalui.
Sebagai tambahan, jika graf yang didefinisikan memiliki bobot pada setiap tepi, maka
kita sebenarnya dapat mengadaptasi algoritma BFS untuk menghitung jarak dengan
menambahkan bobot tepi ke dalam pertimbangan saat menentukan jalur terpendek.
4. Visualisasi, dan integrasi komponen proyek
Terakhir, visualisasi ditambahkan ke dalam proyek. Antarmuka grafis akan
menampilkan labirin, proses algoritma pencarian jalur, dan jalur terpendek yang ditemukan.
Visualisasi memungkinkan pengguna untuk melihat bagaimana algoritma beroperasi dan
bagaimana jalur terpendek ditemukan. Pada bagian ini, penulis mengusahakan suatu script
yang mengkoneksikan semua komponen proyek yang dikaji. Mulai dari pembuatan labirin
nya dengan mengimplementasikan algoritma rekursif backtracking untuk menghasilkan
labirin secara acak, kemudian mengubah bentuk labirin menjadi bentuk graft, penggunaan
Algoritma BFS dan Dijkstra dalam menentukan jalur terpendek pada suatu graft, visualisasi
hasil. Berikut adalah script python yang diupayakan penulis dalam memenuhi kombinasi
seluruh komponen proyek yang ditentukan :

import tkinter as tk
from tkinter import Canvas, Label, Button, messagebox
from dijkstraPencariJalur import dijkstra
from BreadthFirstSearch_Algoritm_jalan_terpendek import bfs
class MazeSolverGUI:
def __init__(self, root, maze, start, end):
self.root = root
self.root.title("Maze Solver")
self.maze = maze
self.start = start
self.end = end
self.canvas_size = 400
self.cell_size = self.canvas_size // len(self.maze)
self.canvas = Canvas(root, width=self.canvas_size, height=self.canvas_size)
self.canvas.pack()
self.label = Label(root, text="Choose Algorithm:")
self.label.pack()
self.dijkstra_button = Button(root, text="Dijkstra", command=self.solve_dijkstra)
self.dijkstra_button.pack()
self.bfs_button = Button(root, text="BFS", command=self.solve_bfs)
self.bfs_button.pack()
self.draw_maze()
def draw_maze(self):
for i in range(len(self.maze)):
for j in range(len(self.maze[i])):
 x1, y1 = j * self.cell_size, i * self.cell_size
x2, y2 = x1 + self.cell_size, y1 + self.cell_size
color = "white" if self.maze[i][j] == 0 else "black"
self.canvas.create_rectangle(x1, y1, x2, y2, fill=color)
self.canvas.create_rectangle(
self.start[1] * self.cell_size,
self.start[0] * self.cell_size,
(self.start[1] + 1) * self.cell_size,
(self.start[0] + 1) * self.cell_size,
fill="green",
)
self.canvas.create_rectangle(
self.end[1] * self.cell_size,
self.end[0] * self.cell_size,
(self.end[1] + 1) * self.cell_size,
(self.end[0] + 1) * self.cell_size,
fill="red",
)
def solve_dijkstra(self):
path, distance = dijkstra(self.maze, self.start, self.end)
self.highlight_path(path)
def solve_bfs(self):
path = bfs(self.maze, self.start, self.end)
self.highlight_path(path)
def highlight_path(self, path):
if not path:
messagebox.showinfo("Path not found", "No path found!")
return
for i, j in path:
x1, y1 = j * self.cell_size, i * self.cell_size
 x2, y2 = x1 + self.cell_size, y1 + self.cell_size
self.canvas.create_rectangle(x1, y1, x2, y2, fill="yellow")
if __name__ == "__main__":
# Contoh labirin, titik awal, dan titik akhir
maze_example = [
[0, 0, 0, 1, 0],
[1, 1, 0, 1, 0],
[0, 0, 0, 0, 0],
[0, 1, 1, 1, 1],
[0, 0, 0, 0, 0],
]
start_point = (0, 0)
end_point = (4, 4)
root_window = tk.Tk()
maze_solver_gui = MazeSolverGUI(root_window, maze_example, start_point,
end_point)
root_window.mainloop()

Untuk membuat antarmuka grafis (GUI) yang menampilkan labirin dan proses
algoritma pencarian jalur, kita dapat menggunakan pustaka GUI seperti Tkinter untuk Python.
Diatas merupakan contoh singkat membuat antarmuka grafis pencarian jalur. Bisa dipilih
dengan menggunakan algoritma yang mana, karena kedua algoritma telah dimasukkan
pustakanya ke script python “Visualisasi_penggunaanAlgoritma_BFS_Dijkstra.py”. Bila kita
ingin menggunakan algoritma BFS untuk mendeteksi jalur terpendek labirin pada kasus ini,
cukup ditekan tombol BFS pada hasil run CMD diatas. Begitupula bila kita menginginkan
eksekusi pencarian jalur terpendek dengan algoritma Dijkstra.

F. Hasil proyek
Adapun yang menjadi hasil akhir dari pengerjaan proyek kali ini meliputi :
a. Program Pembuatan Labirin
Program (script) ini dibuat berdasarkan aturan bahasa python dengan mengimplementasikan
algoritma rekursif backtracking untuk menghasilkan labirin secara acak.
import random
import pygame
import sys

# Inisialisasi Pygame
pygame.init()

# Dimensi layar
WIDTH, HEIGHT = 600, 600

# Warna
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
CELL_SIZE = 20

# Inisialisasi labirin
maze_rows = HEIGHT // CELL_SIZE
maze_cols = WIDTH // CELL_SIZE
maze = [[0] * maze_cols for _ in range(maze_rows)]

# Inisialisasi layar
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Maze Generator")

def draw_maze():
screen.fill(WHITE)
for row in range(maze_rows):
for col in range(maze_cols):
color = WHITE if maze[row][col] == 0 else BLACK
pygame.draw.rect(screen, color, (col * CELL_SIZE, row * CELL_SIZE,
CELL_SIZE, CELL_SIZE))
pygame.display.flip()

def recursive_backtracking(row, col):

 directions = [(0, 2), (2, 0), (0, -2), (-2, 0)] # Move in increments of 2 to create walls
between paths
random.shuffle(directions)

for dr, dc in directions:

new_row, new_col = row + dr, col + dc
if 0 <= new_row < maze_rows and 0 <= new_col < maze_cols and
maze[new_row][new_col] == 0:
maze[new_row][new_col] = 1
maze[(row + new_row) // 2][(col + new_col) // 2] = 1 # Break the wall
between cells
recursive_backtracking(new_row, new_col)

# Generate maze using recursive backtracking

recursive_backtracking(0, 0)

# Draw the initial maze

draw_maze()

while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()

b. Program merepresentasikan bentuk labirin menjadi graft

# Import library yang diperlukan
import pygame
import sys
import random

# Inisialisasi Pygame
pygame.init()
# Dimensi layar
WIDTH, HEIGHT = 600, 600
# Warna
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
CELL_SIZE = 20
# Inisialisasi labirin
maze_rows = HEIGHT // CELL_SIZE
maze_cols = WIDTH // CELL_SIZE
maze = [[0] * maze_cols for _ in range(maze_rows)]
# Inisialisasi layar
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Maze Generator")
def draw_maze():
screen.fill(WHITE)
for row in range(maze_rows):
for col in range(maze_cols):
color = WHITE if maze[row][col] == 0 else BLACK
pygame.draw.rect(screen, color, (col * CELL_SIZE, row * CELL_SIZE,
CELL_SIZE, CELL_SIZE))
pygame.display.flip()
def recursive_backtracking(row, col):
directions = [(0, 2), (2, 0), (0, -2), (-2, 0)] # Move in increments of 2 to create walls
between paths
random.shuffle(directions)
for dr, dc in directions:
new_row, new_col = row + dr, col + dc
if 0 <= new_row < maze_rows and 0 <= new_col < maze_cols and maze[new_row]
[new_col] == 0:
maze[new_row][new_col] = 1
maze[(row + new_row) // 2][(col + new_col) // 2] = 1 # Break the wall between cells
recursive_backtracking(new_row, new_col)
# Generate maze using recursive backtracking
recursive_backtracking(0, 0)
# Draw the initial maze
draw_maze()
# Inisialisasi objek graf
maze_graph = {}
# Fungsi untuk menambahkan edge antara node-node yang bersebelahan
def add_edges_from_maze(maze, maze_graph):
rows = len(maze)
cols = len(maze[0])
for row in range(rows):
for col in range(cols):
if maze[row][col] == 0: # Hanya tambahkan edge untuk sel yang merupakan jalur
maze_graph[(row, col)] = []
# Cek atas
if row > 0 and maze[row - 1][col] == 0:
maze_graph[(row, col)].append((row - 1, col))
# Cek bawah
if row < rows - 1 and maze[row + 1][col] == 0:
maze_graph[(row, col)].append((row + 1, col))
# Cek kiri
if col > 0 and maze[row][col - 1] == 0:
maze_graph[(row, col)].append((row, col - 1))
# Cek kanan
if col < cols - 1 and maze[row][col + 1] == 0:
maze_graph[(row, col)].append((row, col + 1))
# Menambahkan edge dari labirin ke graf
add_edges_from_maze(maze, maze_graph)
# Gunakan maze_graph seperti yang diinginkan.
print("Representasi Graf dari Labirin:")
print(maze_graph)
c. Script pencarian jalur terpendek berbahasa pemrograman python, implementasi
dari Algoritma Pencarian Jalur: Breadth-First Search (BFS)
from collections import defaultdict, deque
class Graf:
def __init__(self):
self.graph = defaultdict(list)
def tambah_edge(self, u, v):
self.graph[u].append(v)
self.graph[v].append(u)
def bfs(self, mulai, akhir):
visited = set()
queue = deque([[mulai]])
if mulai == akhir:
return f"Sudah berada di simpul akhir {akhir}"
while queue:
path = queue.popleft()
node = path[-1]
if node not in visited:
tetangga = self.graph[node]
for tetangga_node in tetangga:
new_path = list(path)
new_path.append(tetangga_node)
queue.append(new_path)
if tetangga_node == akhir:
return f"Jalur terpendek: {new_path}"
visited.add(node)
return "Tidak ditemukan jalur antara kedua simpul"
# Contoh penggunaan
graf = Graf()
graf.tambah_edge('A', 'B')
graf.tambah_edge('B', 'C')
 graf.tambah_edge('B', 'D')
graf.tambah_edge('C', 'D')
graf.tambah_edge('D', 'E')
simpul_mulai = 'A'
simpul_akhir = 'E'
hasil_bfs = graf.bfs(simpul_mulai, simpul_akhir)
print(hasil_bfs)

d. Script pencarian jalur terpendek berbahasa pemrograman python, implementasi

dari Algoritma Pencarian Jalur: Dijkstra
import heapq
def dijkstra(graph, start, end):
# Inisialisasi kamus untuk menyimpan jarak terpendek dari start ke setiap node
distances = {node: float('infinity') for node in graph}
distances[start] = 0

# Inisialisasi priority queue (heap) untuk menyimpan node-node yang akan dieksplorasi
priority_queue = [(0, start)]
while priority_queue:
current_distance, current_node = heapq.heappop(priority_queue)
# Skip jika node ini sudah dieksplorasi sebelumnya
if current_distance > distances[current_node]:
continue
for neighbor, weight in graph[current_node].items():
distance = current_distance + weight
# Perbarui jarak terpendek jika ditemukan jarak yang lebih pendek
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(priority_queue, (distance, neighbor))
# Jalur terpendek dari start ke end
path = []
 current = end
while current != start:
path.insert(0, current)
current = min(graph[current], key=lambda x: distances[x])
path.insert(0, start)
return path, distances[end]
# Contoh penggunaan
graph = {
'A': {'B': 1, 'C': 4},
'B': {'A': 1, 'C': 2, 'D': 5},
'C': {'A': 4, 'B': 2, 'D': 1},
'D': {'B': 5, 'C': 1}
}
start_node = 'A'
end_node = 'D'
shortest_path, shortest_distance = dijkstra(graph, start_node, end_node)
print(f"Jalur terpendek dari {start_node} ke {end_node}: {shortest_path}")
print(f"Jarak terpendek: {shortest_distance}")

e. Script integrasi semua komponen proyek sehingga dapat divisualisasikan

import tkinter as tk
from tkinter import Canvas, Label, Button, messagebox
from dijkstraPencariJalur import dijkstra
from BreadthFirstSearch_Algoritm_jalan_terpendek import bfs
class MazeSolverGUI:
def __init__(self, root, maze, start, end):
self.root = root
self.root.title("Maze Solver")
self.maze = maze
self.start = start
 self.end = end
self.canvas_size = 400
self.cell_size = self.canvas_size // len(self.maze)
self.canvas = Canvas(root, width=self.canvas_size, height=self.canvas_size)
self.canvas.pack()
self.label = Label(root, text="Choose Algorithm:")
self.label.pack()
self.dijkstra_button = Button(root, text="Dijkstra", command=self.solve_dijkstra)
self.dijkstra_button.pack()
self.bfs_button = Button(root, text="BFS", command=self.solve_bfs)
self.bfs_button.pack()
self.draw_maze()
def draw_maze(self):
for i in range(len(self.maze)):
for j in range(len(self.maze[i])):
x1, y1 = j * self.cell_size, i * self.cell_size
x2, y2 = x1 + self.cell_size, y1 + self.cell_size
color = "white" if self.maze[i][j] == 0 else "black"
self.canvas.create_rectangle(x1, y1, x2, y2, fill=color)
self.canvas.create_rectangle(
self.start[1] * self.cell_size,
self.start[0] * self.cell_size,
(self.start[1] + 1) * self.cell_size,
(self.start[0] + 1) * self.cell_size,
fill="green",
)
self.canvas.create_rectangle(
self.end[1] * self.cell_size,
self.end[0] * self.cell_size,
(self.end[1] + 1) * self.cell_size,
 (self.end[0] + 1) * self.cell_size,
fill="red",
)
def solve_dijkstra(self):
path, distance = dijkstra(self.maze, self.start, self.end)
self.highlight_path(path)
def solve_bfs(self):
path = bfs(self.maze, self.start, self.end)
self.highlight_path(path)
def highlight_path(self, path):
if not path:
messagebox.showinfo("Path not found", "No path found!")
return
for i, j in path:
x1, y1 = j * self.cell_size, i * self.cell_size
x2, y2 = x1 + self.cell_size, y1 + self.cell_size
self.canvas.create_rectangle(x1, y1, x2, y2, fill="yellow")
if __name__ == "__main__":
# Contoh labirin, titik awal, dan titik akhir
maze_example = [
[0, 0, 0, 1, 0],
[1, 1, 0, 1, 0],
[0, 0, 0, 0, 0],
[0, 1, 1, 1, 1],
[0, 0, 0, 0, 0],
]
start_point = (0, 0)
end_point = (4, 4)
root_window = tk.Tk()
maze_solver_gui = MazeSolverGUI(root_window, maze_example, start_point, end_point)
root_window.mainloop()

f. Flowchart