Bài Tập Lớn Trí Tuệ Nhân Tạo Cài đặt các thuật toán tìm kiếm chiều sâu, tìm kiếm chiều rộng

Tiểu luận Lập trình trí tuệ nhân tạo
Bài Tập Lớn Trí Tuệ Nhân Tạo
Đề bài : Cài đặt các thuật toán tìm kiếm chiều sâu, tìm kiếm
chiều rộng
Giảng viên hướng dẫn : PGS.TS Phan Huy Khánh
Nhóm học viên thực hiện:
1. Lê Nam Trung
2. Nguyễn Nương Quỳnh
3. Nguyễn Duy Linh
4. Hoàng Đình Tuyền
1
Tiểu luận Lập trình trí tuệ nhân tạo
Mục Lục
Phần 1 : Lời nói đầu
1.Mục đích của đề bài…………………………………………
2.Phân công công việc…………………………………………
Phần 2: Thuật Toán Tìm Kiếm Theo Chiều Sâu
1. Sơ lược thuật toán tìm kiếm chiều sâu…………………………… 4
2. Kĩ thuật tìm kiếm chiều sâu………………………………………. 4
3. Giải thuật
4. Ví dụ
5. Ưu điểm và nhược điểm của tìm kiếm chiều sâu
Phần 3: Thuật Toán Tìm Kiếm Theo Chiều Rộng………………… 8
1. Sơ lược thuật toán tìm kiếm chiều rộng…………………………… 8
2. Kĩ thuật tìm kiếm theo chiều rộng………………………………… 9
3. Giải thuật
4. Ví dụ
5. Ưu điểm và nhược điểm của tìm kiếm chiều rộng
Phần 4: So sánh hai thuật toán tìm kiếm chiều sâu và chiều rông…. 15
Tài Liệu Tham Khảo
I.Lời mở đầu

1.Mục đích của thuật toán
2
Tiểu luận Lập trình trí tuệ nhân tạo
Mục đích chính của các thuật toán tìm kiếm chiều sâu và chiều rộng là tìm ra lời
giải tối ưu nhất cho bài toán trong thời gian nhỏ nhất. Các thuật toán như tìm kiếm
không có thông tin / vét cạn ( tìm kiếm trên danh sách, trên cây hoặc đồ thị ) sử dụng
phương pháp đơn giản nhất và trực quan nhất để áp dụng các tri thức về cấu trúc của
không gian tìm kiếm nhằm giảm thời gian cần thiết cho việc tìm kiếm được sử dụng
nhiều .Tuy nhiên, do bản chất là vét cạn nên với những bài toán có không gian lớn thì ta không
thể dùng hai chiến lược này được. Hơn nữa, hai chiến lược này đều có tính chất "mù quáng" vì
chúng không chú ý đến những thông tin (tri thức) ở trạng thái hiện thời và thông tin về đích cần
đạt tới cùng mối quan hệ giữa chúng.
2.Phân công công việc
_ Sưu tầm tài liệu: cả nhóm thực hiện.
_ Soạn lý thuyết: cả nhóm thực hiện.
_ Soạn chương trình demo: cả nhóm thực hiện.
_ In ấn, báo cáo: Hoàng Đình Tuyền
II. Thuật toán tìm kiếm chiều sâu.
1. Sơ lược thuật toán tìm kiếm chiều sâu:
Trong tìm kiếm theo chiều sâu, tại trạng thái (đỉnh) hiện hành, ta chọn một trạng thái kế
tiếp (trong tập các trạng thái có thể biến đổi thành từ trạng thái hiện tại) làm trạng thái hiện
hành cho đến lúc trạng thái hiện hành là trạng thái đích. Trong trường hợp tại trạng thái hiện
hành, ta không thể biến đổi thành trạng thái kế tiếp thì ta sẽ quay lui (back-tracking) lại trạng
thái trước trạng thái hiện hành (trạng thái biến đổi thành trạng thái hiện hành) để chọn đường
khác. Nếu ở trạng thái trước này mà cũng không thể biến đổi được nữa thì ta quay lui lại trạng
thái trước nữa và cứ thế. Nếu đã quay lui đến trạng thái khởi đầu mà vẫn thất bại thì kết luận là
không có lời giải. Hình ảnh sau minh họa hoạt động của tìm kiếm theo chiều sâu.
3
Tiểu luận Lập trình trí tuệ nhân tạo
Hình 1: Hình ảnh của tìm kiếm chiều sâu. Nó chỉ lưu ý "mở rộng" trạng thái được chọn

mà không "mở rộng" các trạng thái khác (nút màu trắng trong hình vẽ).
4
Tiểu luận Lập trình trí tuệ nhân tạo
2. Kỹ thuật tìm kiếm chiều sâu:
Tìm kiếm sâu trong không gian bài toán được bắt đầu từ một nút rồi tiếp tục cho đến khi hoặc
đến ngõ cụt hoặc đến đích. Tại mỗi nút có luật trong tài, chẳng hạn, “đi theo nút cực trái”,
hướng dẫn việc tìm. Nếu không đi tiếp được, gọi là đến ngõ cụt, hệ thống quay lại một mức trên
đồ thị và tìm theo hướng khác, chẳng hạn, đến nút “sát nút cực trái”. Hành động này gọi là quay
lui.
Thuật toán tìm kiếm theo chiều sâu được hình dung như việc khảo sát một cây bắt đầu từ gốc đi
theo mọi cành có thể được, khi gặp cành cụt thì quay lại xét cành chưa đi qua.
- Ở bước tổng quát, giả sử đang xét đỉnh i, khi đó các đỉnh kề với i có các trường hợp:
+ Nếu tồn tại đỉnh j kề i chưa được xét thì xét đỉnh này (nó trở thành đỉnh đã xét) và bắt đầu từ
đó tiếp tục quá trình tìm kiếm với đỉnh này
+ Nếu với mọi đỉnh kề với i đều đã được xét thì i coi như duyệt xong và quay trở lại tìm kiếm từ
đỉnh mà từ đó ta đi đến được i.

Ví dụ:
Cho cây như hình vẽ:
Đỉnh đầu: A
Đỉnh Đích: J
Các bước chi tiết thực hiện giải thuật:
Lần Lặp L = Ø
U U € T V L
0 A
1 False A False B,C,D D,C,B
2 False D False H H,C,B
5
J
HGFE

DCB
A
Tiểu luận Lập trình trí tuệ nhân tạo
3 False H False Ø C,B
4 False C False G G,B
5 False G False J J,B
6 False J True
Ta có J ∈ DICH ⇒ Thành Công. Xây dựng đường đi. A → C → G → J.
Kết quả đường đi trên cây là:
3. Cài đặt chương trình
domains
d = integer
STATE = state(D STRING,D STRING)
PATH = STATE*
predicates
nondeterm stack(STATE,PATH,PATH)
6
J
HGFE
DCB
A
Tiểu luận Lập trình trí tuệ nhân tạo
nondeterm member(STATE,PATH)
nondeterm member_set(STATE,PATH)
nondeterm member_stack(STATE,PATH)
add_if_not_in_set(STATE,PATH,PATH)
nondeterm path(PATH,PATH,PATH,STATE)
empty_set(PATH)
empty_stack(PATH)
nondeterm go(STATE,STATE)

nondeterm move(STATE,STATE)
nondeterm reverse_print_stack(PATH)
nondeterm test
clauses
path(Open_stack,_,_,_):-
empty_stack(Open_stack),
write("No solution found with these rules").
path(Open_stack,_,Path_stack,Goalstate):-
stack(Top,_,Open_stack),Top = Goalstate,
write("A solution found :\n"),
7
Tiểu luận Lập trình trí tuệ nhân tạo
reverse_print_stack(Path_stack).
path(Open_stack,Closed_set,Path_stack,Goalstate):-
stack(Top,Res_open_stack,Open_stack),
move(Top,Next_state),
not(member_stack(Next_state,Open_stack)),
not(member_set(Next_state,Closed_set)),
stack(Next_state,Res_open_stack,New_open_stack),
stack(Next_state,Path_stack,New_path_stack),
add_if_not_in_set(Next_state,Closed_set,New_closed_set),
path(New_open_stack,New_closed_set,New_path_stack,Goalstate),!.
go(Start,Goalstate):-
empty_stack(Open),
empty_stack(Path),
empty_set(Closed),
stack(Start,Open,Open_stack),
stack(Start,Path,Path_stack),
add_if_not_in_set(Start,Closed,Closed_set),
path(Open_stack,Closed_set,Path_stack,Goalstate).

8
Tiểu luận Lập trình trí tuệ nhân tạo
move(state(X,Y),state(New_x,New_y)):- X < 4,New_x = 4, New_y = Y.
move(state(X,Y),state(New_x,New_y)):- Y < 3, New_x = X, New_y = 3.
move(state(X,Y),state(New_x,New_y)):- X > 0, New_x = 0, New_y = Y.
move(state(X,Y),state(New_x,New_y)):- Y >0, New_x = X, New_y = 0.
move(state(X,Y),state(New_x,New_y)):- X + Y >= 4,
Y > 0,New_x = 4, New_y = Y - (4 - X).
move(state(X,Y),state(New_x,New_y)):- X + Y >= 3,
X > 0,New_x = X - (3 - Y),New_y = 3.
move(state(X,Y),state(New_x,New_y)):- X + Y < 0,
Y > 0,New_x = X + Y, New_y = 0.
move(state(X,Y),state(New_x,New_y)):- X + Y < 3,
X > 0,New_x = 0,New_y = X + Y.

empty_stack([]).
empty_set([]).
stack(Top,Stack,[Top|Stack]).
reverse_print_stack(S):-
empty_stack(S).
reverse_print_stack(S):-
9
Tiểu luận Lập trình trí tuệ nhân tạo
stack(E,Res,S),
reverse_print_stack(Res),write(E),nl.
member(X,[X|_]):-
!.
member(X,[_|L]):-
member(X,L).
member_stack(Element,Stack):- member(Element,Stack).

member_set(S,L):- member(S,L).
add_if_not_in_set(X,S,S):-
member(X,S),!.
add_if_not_in_set(X,S,[X|S]).
test:-
go(state(0,0),state(2,_)).
goal
test.
10
Tiểu luận Lập trình trí tuệ nhân tạo
5. Ưu và nhược điểm của phương pháp tìm kiếm chiều sâu:
Ưu điểm:
- Nếu bài toán có lời giải, phương pháp tìm kiếm sâu bảo đảm tìm ra lời giải.
- Kỹ thuật tìm kiếm sâu tập trung vào đích, con người cảm thấy hài lòng khi các câu hỏi tập
trung vào vấn đề chính.
- Do cách tìm của kỹ thuật này, nếu lời giải ở rất sâu, kỹ thuật tìm sâu sẽ tiết kiệm thời gian.
Nhược điểm:
- Tìm sâu khai thác không gian bài toán để tìm lời giải theo thuật toán đơn giản một cách cứng
nhắc. Trong quá trình tìm nó không có thông tin nào hổ trợ để phát hiện lời giải. Nếu chọn nút
ban đầu không thích hợp có thể không dẫn đến đích của bài toán.
- Không phù hợp với không gian bài toán lớn, kỹ thuật tìm kiếm sâu có thể không đến lời giải
trong khoảng thời gian vừa phải.
11
Tiểu luận Lập trình trí tuệ nhân tạo
III. Thuật toán tìm kiếm chiều rộng.
1: Sơ lược thuật toán tìm kiếm chiều rộng:
Ngược lại với tìm kiếm theo kiểu chiều sâu, tìm kiếm chiều rộng mang hình ảnh của vết
dầu loang. Từ trạng thái ban đầu, ta xây dựng tập hợp S bao gồm các trạng thái kế tiếp (mà từ
trạng thái ban đầu có thể biến đổi thành). Sau đó, ứng với mỗi trạng thái Tk trong tập S, ta xây
dựng tập Sk bao gồm các trạng thái kế tiếp của Tk

rồi lần lượt bổ sung các Sk vào S. Quá trình
này cứ lặp lại cho đến lúc S có chứa trạng thái kết thúc hoặc S không thay đổi sau khi đã bổ
sung tất cả Sk.
Hình 2 : Hình ảnh của tìm kiếm chiều rộng. Tại một bước, mọi trạng thái đều được mở
rộng, không bỏ sót trạng thái nào.
2. Kỹ thuật tìm kiếm chiều rộng:
Kỹ thuật tìm kiếm rông là tìm kiếm trên tất cả các nút của một mức trong không gian bài
toán trước khi chuyển sang các nút của mức tiếp theo.
Kỹ thuật tìm kiếm rộng bắt đầu từ mức thứ nhất của không gian bài toán, theo hướng dẫn của
12
Tiểu luận Lập trình trí tuệ nhân tạo
luật trọng tài, chẳng hạn “đi từ trái sang phải”. Nếu không thấy lời giải tại mức này, nó chuyển
xuống mức sau để tiếp tục … đến khi định vị được lời giải nếu có.
Ví dụ:
Cho cây như hình vẽ:
Đỉnh đầu: A
Đỉnh đích: K
13
F H
LKJ
E
D
CB
A
G
P
I
Tiểu luận Lập trình trí tuệ nhân tạo
Các bước chi tiết thực hiện giải thuật:

Lần Lặp L = Ø
U U € T V L
0 A
1 False A False B,C,D B,C,D
2 False B False E,F C,D,E,F
3 False C False G D,E,F,G
4 False D False H,I E,F,G,H,I
5 False E False J,K F,G,H,I,J,K
6 False F False Ø G,H,I,J,K
7 False G False L H,I,J,K,L
8 False H False Ø I,J,K,L
9 False I False P J,K,L,P
10 False J False Ø K,L,P
11 False K True
Ta có K ∈ Đích ⇒ Thành công. Xây dựng đường đi: A → B → E → K
Kết quả đường đi trên cây:
14
LKJ
E
D
CB
A
G
P
I
F
H
Tiểu luận Lập trình trí tuệ nhân tạo
15
Tiểu luận Lập trình trí tuệ nhân tạo

3. Cài đặt chương trình
Domains
d = integer
STATE = state(D STRING,D STRING)
PATH = STATE*
predicates
nondeterm member(STATE,PATH)
nondeterm member_set(STATE,PATH)
add_if_not_in_set(STATE,PATH,PATH)
nondeterm path(PATH,PATH,STATE)
empty_set(PATH)
empty_queue(PATH)
nondeterm go(STATE,STATE)
nondeterm move(STATE,STATE)
nondeterm dequeue(STATE,PATH,PATH)
nondeterm add_to_queue(STATE,PATH,PATH)
nondeterm moves(STATE,PATH,PATH,STATE)
get_children(STATE,PATH,PATH,PATH)
nondeterm union(PATH,PATH,PATH)
nondeterm append(PATH,PATH,PATH)
nondeterm add_list_to_queue(PATH,PATH,PATH)
nondeterm member_queue(STATE,PATH)
nondeterm printsolution(STATE,PATH)
16
Tiểu luận Lập trình trí tuệ nhân tạo
nondeterm reverse_writelist(PATH)
nondeterm test
clauses
go(Start,Goalstate):-
empty_queue(Empty_open_queue),

add_to_queue(Start,Empty_open_queue,Open_queue),
empty_set(Closed_set),
path(Open_queue,Closed_set,Goalstate).
path(Open_queue,_,_):-
empty_queue(Open_queue),
write("Graph search, no solution found.").
path(Open_queue,Closed_set,Goalstate):-
dequeue(State,Open_queue,_),
State = Goalstate,
write("Solution path is : "),
printsolution(State,Closed_set),nl,reverse_writelist(Closed_set).
path(Open_queue,Closed_set,Goalstate):-
dequeue(State,Open_queue,Res_open_queue),
get_children(State,Res_open_queue,Closed_set,Children),
add_list_to_queue(Children,Res_open_queue,New_open_queue),
17
Tiểu luận Lập trình trí tuệ nhân tạo
union([State,_],Closed_set,New_closed_set),
path(New_open_queue,New_closed_set,Goalstate),!.
get_children(State,Res_open_queue,Closed_set,Children):-
findall(Child,moves(State,Res_open_queue,
Closed_set,Child),Children).
moves(State,Res_open_queue,Closed_set,Next):-
move(State,Next),
not(member_queue(Next,Res_open_queue)),
not(member_set(Next,Closed_set)).
printsolution(State,_):-
write(State),nl.
printsolution(State,Closed_set):-
member_set(State,Closed_set),

printsolution(State,Closed_set),
write(State),nl.
move(state(X,Y),state(New_x,New_y)):- X < 4,New_x = 4, New_y = Y.
move(state(X,Y),state(New_x,New_y)):- Y < 3, New_x = X, New_y = 3.
move(state(X,Y),state(New_x,New_y)):- X > 0, New_x = 0, New_y = Y.
move(state(X,Y),state(New_x,New_y)):- Y >0, New_x = X, New_y = 0.
move(state(X,Y),state(New_x,New_y)):- X + Y >= 4,
Y > 0,New_x = 4, New_y = Y - (4 - X).
18
Tiểu luận Lập trình trí tuệ nhân tạo
move(state(X,Y),state(New_x,New_y)):- X + Y >= 3,
X > 0,New_x = X - (3 - Y),New_y = 3.
move(state(X,Y),state(New_x,New_y)):- X + Y < 4,
Y > 0,New_x = X + Y, New_y = 0.
move(state(X,Y),state(New_x,New_y)):- X + Y < 3,
X > 0,New_x = 0,New_y = X + Y.
reverse_writelist([]).
reverse_writelist([H|T]):- reverse_writelist(T),write(H),nl.
empty_queue([]).
empty_set([]).
member(X,[X|_]):-
!.
member(X,[_|L]):-
member(X,L).
member_queue(State,Queue):- member(State,Queue).
dequeue(E,[E|T],T).
/*dequeue(E,[E|_],_).*/
add_to_queue(E,[],[E]).
add_to_queue(E,[H|T],[H|Tnew]):- add_to_queue(E,T,Tnew).
append([],L,L).

append([X|T],L,[X|NL]):- append(T,L,NL).
add_list_to_queue(List,Queue,Newqueue):-
append(Queue,List,Newqueue).
member_set(S,L):- member(S,L).
19
Tiểu luận Lập trình trí tuệ nhân tạo
add_if_not_in_set(X,S,S):-
member(X,S),!.
add_if_not_in_set(X,S,[X|S]).
union([],S,S).
union([H|T],S,S_new):-
union(T,S,S2),
add_if_not_in_set(H,S2,S_new).
test:- go(state(0,0),state(2,0)).
goal
test.
5. Ưu và nhược điểm của phương pháp tìm kiếm rộng.
Ưu điểm
- Kỹ thuật tìm kiếm rộng là kỹ thuật vét cạn không gian trạng thái bài toán vì vậy sẽ tìm được
lời giải nếu có.
- Đường đi tìm được đi qua ít đỉnh nhất.
Nhược điểm
- Tìm kiếm lời giải theo thuật toán đã định trước, do vậy tìm kiếm một cách máy móc; khi
không có thông tin hổ trợ cho quá trình tìm kiếm, không nhận ra ngay lời giải.
- Không phù hợp với không gian bài toán kích thước lớn. Đối với loại bài toán này, phương
pháp tìm rộng đối mặt với các nhu cầu:
+ Cần nhiều bộ nhớ theo số nút cần lưu trữ.
+ Cần nhiều công sức xử lý các nút, nhất là khi các nhánh cây dài, số nút tăng.
20
Tiểu luận Lập trình trí tuệ nhân tạo

+ Dễ thực hiện các thao tác không thích hợp, thừa, đưa đến việc tăng đáng kể số nút phải xử lý.
- Không hiệu qủa nếu lời giải ở sâu. Phương pháp này không phù hợp cho trường hợp có nhiều
đường dẫn đến kết quả nhưng đều sâu.
- Giao tiếp với người dùng không thân thiện. Do duyệt qua tất cả các nút, việc tìm kiếm không
tập trung vào một chủ đề.
21
Tiểu luận Lập trình trí tuệ nhân tạo
IV. So sánh thuật toán tìm kiếm chiều sâu, tìm kiếm chiều rộng.
Chiều sâu Chiều rộng
Tính hiệu quả Hiệu quả khi lời giải nằm
sâu trong cây tìm kiếm và có
một phương án chọn hướng
đi chính xác. Hiệu quả của
chiến lược phụ thuộc vào
phương án chọn hướng đi.
Phương án càng kém hiệu
quả thì hiệu quả của chiến
lược càng giảm. Thuận lợi
khi muốn tìm chỉ một lời
giải.
Hiệu quả khi lời giải
nằm gần gốc của cây
tìm kiếm. Hiệu quả
của chiến lược phụ
thuộc vào độ sâu của
lời giải. Lời giải càng
xa gốc thì hiệu quả của
chiến lược càng giảm.
Thuận lợi khi muốn
tìm nhiều lời giải.

Lượng bộ nhớ sử
dụng để lưu trữ các
trạng thái
Chỉ lưu lại các trạng thái
chưa xét đến.
Phải lưu toàn bộ các
trạng thái.
Trường hợp xấu nhất Vét cạn toàn bộ Vét cạn toàn bộ.
Trường hợp tốt nhất Phương án chọn hướng đi
tuyệt đối chính xác. Lời giải
được xác định một cách trực
tiếp.
Vét cạn toàn bộ.
Tìm kiếm chiều sâu và tìm kiếm chiều rộng đều là các phương pháp tìm kiếm có hệ
thống và chắc chắn tìm ra lời giải. Tuy nhiên, do bản chất là vét cạn nên với những bài toán có
không gian lớn thì ta không thể dùng hai chiến lược này được. Hơn nữa, hai chiến lược này đều
22
Tiểu luận Lập trình trí tuệ nhân tạo
có tính chất "mù quáng" vì chúng không chú ý đến những thông tin (tri thức) ở trạng thái hiện
thời và thông tin về đích cần đạt tới cùng mối quan hệ giữa chúng.
23