TRƯỜNG ĐẠI HỌC BÁCH KHOA

KHOA Công Nghệ Thông Tin

BỘ MÔN: Công Nghệ Phần Mềm
ĐỀ THI VÀ BÀI LÀM
Tên học phần: Trí tuệ nhân tạo
Mã học phần: Hình thức thi: Tự luận có giám sát
Đề số: 0001 Thời gian làm bài: 60 phút (không kể thời gian chép/phát đề)
Được sử dụng tài liệu khi làm bài.

Họ tên: ……………………………Lớp:……………………………MSSV:……………………...

Sinh viên làm bài trực tiếp trên tệp này, lưu tệp với định dạng MSSV_HọTên.pdf và nộp bài thông qua MSTeam:
Câu 1 (4 điểm): Cho đồ thị vô hướng G = (V,E) như hình vẽ với V là tập đỉnh và E là tập cạnh.

a) (2 điểm) Hãy viết đoạn code biểu diễn đồ thị trên bằng cách khởi tạo tập đỉnh V và tập cạnh E.
(Ví dụ: V = [“S”, “A”, “B”], E =[(“S”, “A”), (“S”, “B”)])
# Trả lời: Dán code vào bên dưới
graph = {
'S' : ['A', 'B', 'C'],
'A' : ['D', 'B', 'S'],
'B' : ['G', 'A', 'D', 'S', 'F', 'C'],
'C' : ['S', 'B', 'F'],
'D' : ['A', 'B', 'E'],
'E' : ['G', 'F', 'D'],
'F' : ['C', 'B', 'E', 'H'],
'G' : ['B', 'E', 'H'],
'H' : ['F', 'G']
}

b) (2 điểm) Hãy viết chương trình sử dụng thuật toán tìm kiếm theo chiều rộng (BFS) để tìm đường đi từ
đỉnh “S” đến đỉnh “G” trong đồ thị được biểu diễn ở câu a). Trong chương trình, hãy in ra thứ tự đỉnh
khám phá trong quá trình tìm kiếm. Nếu không tìm thấy thì in “Khong tim thay duong di”
# Trả lời: Dán code vào bên dưới
 def BFS(initialState, goal):
frontier = [initialState]
explored = []
while frontier:
state = frontier.pop(0)
explored.append(state)
if goal == state:
return explored

for neighbor in graph[state]:

if neighbor not in explored:
if neighbor not in frontier:
frontier.append(neighbor)
return False
if __name__ == '__main__':
graph = {
'S' : ['A', 'B', 'C'],
'A' : ['D', 'B', 'S'],
'B' : ['G', 'A', 'D', 'S', 'F', 'C'],
'C' : ['S', 'B', 'F'],
'D' : ['A', 'B', 'E'],
'E' : ['G', 'F', 'D'],
'F' : ['C', 'B', 'E', 'H'],
'G' : ['B', 'E', 'H'],
'H' : ['F', 'G']
}
result = BFS('S', 'G')
if result:
s = 'explored: '
for i in result:
s += i + ' '
print(s)
else:
print('Khong tim thay duong di')

# Trả lời: Dán kết quả thực thi vào bên dưới:

Câu 2 (4 điểm): Cho đồ thị vô hướng G = (V,E) như hình vẽ với V là tập đỉnh và E là tập cạnh.
a) (2 điểm) Hãy viết đoạn code biểu diễn đồ thị trên bằng cách khởi tạo tập đỉnh V và tập cạnh E.
(Ví dụ: V = [“S”, “A”, “B”], E =[(“S”, “A”), (“S”, “B”)])
# Trả lời: Dán code vào bên dưới
graph = {
'S' : ['A', 'B', 'C'],
'A' : ['S', 'B', 'D'],
'B' : ['S', 'A', 'D', 'G', 'F', 'C'],
'C' : ['S', 'B', 'F'],
'D' : ['A', 'B', 'E'],
'E' : ['G', 'F', 'D'],
'F' : ['C', 'B', 'E', 'H'],
'G' : ['B', 'E', 'H'],
'H' : ['F', 'G']
}

b) (2 điểm) Hãy viết chương trình sử dụng thuật toán tìm kiếm theo chiều sâu (DFS) để tìm đường đi từ
đỉnh “G” đến đỉnh “S” trong đồ thị được biểu diễn ở câu a). Trong chương trình, hãy in ra thứ tự đỉnh
khám phá trong quá trình tìm kiếm. Nếu không tìm thấy thì in “Khong tim thay duong di”
# Trả lời: Dán code vào bên dưới

def DFS (initialState, goal):

frontier = [initialState]
explored = []
while frontier:
state = frontier.pop(len(frontier) - 1)
explored.append(state)
if goal == state:
return explored
for neighbor in graph[state]:
if neighbor not in (explored):
if neighbor not in (frontier):
frontier.append(neighbor)
return False

if __name__== '__main__':
graph = {
'S' : ['A', 'B', 'C'],
'A' : ['S', 'B', 'D'],
'B' : ['S', 'A', 'D', 'G', 'F', 'C'],
'C' : ['S', 'B', 'F'],
'D' : ['A', 'B', 'E'],
'E' : ['G', 'F', 'D'],
 'F' : ['C', 'B', 'E', 'H'],
'G' : ['B', 'E', 'H'],
'H' : ['F', 'G']
}
result = DFS('G', 'S')
if result:
s = 'explored: '
for i in result:
s += i + ' '
print(s)
else:
print("Khong tim thay duong di")

# Trả lời: Dán kết quả thực thi vào bên dưới:

Câu 3 (2 điểm):
a) (1 điểm) Tính độ phức tạp của BFS và DFS

# Trả lời:
Độ phức tạp của BFS:
-Về mặt thời gian: O(b^d)
-Về mặt không gian lưu trữ: O(b^d)
(trong đó b: độ phân nhánh của cây, d: độ sâu của lời giải ngắn nhất)
Độ phức tạp của DFS:
-Về mặt thời gian: O(b^m)
-Về mặt không gian lưu trữ: O(b^m)
(trong đó b: độ phân nhánh của cây, m: độ sâu tối đa của không gian trạng thái)
b) (1 điểm) So sánh, đánh giá và biện luận độ phức tạp của BFS và DFS

# Trả lời:
Thuật toán DFS:
• Tính đủ
• không ( nếu không gian tìm kiếm vô hạn hoặc lặp)
• đủ ( nếu khử lặp và không gian tìm kiếm hữu hạn)
• Độ phức tạp thời gian
• 0(b^m)
• Nếu hàm đánh giá tốt thì, thời gian thực tế giảm đáng kể
• Độ phức tạp không gian gian
• 0(b.m): độ phức tạp tuyến tính
• Tính tối ưu
 • không
Thuật toán BFS:
• Tính đủ
• có ( nếu b hữu hạn)
• Độ phức tạp thời gian
• 1 + 1.b + b.b + … + b^(d-1). b = 0(b^d)
• Độ phức tạp về lưu trữ
• 0(b^d)
• Tính tối ưu
• có(nếu chi phí cho mỗi bước chuyển là 1 đơn vị ).

Đà Nẵng, ngày 06 tháng 03 năm 2023

GIẢNG VIÊN BIÊN SOẠN ĐỀ THI TRƯỞNG BỘ MÔN
(đã duyệt)