Thông tin tài liệu
153
CHƯƠNG 16
CÁC CHIẾN LƯỢC THIẾT KẾ THUẬT TOÁN
Với một vấn đề đặt ra, làm thế nào chúng ta có thể đưa ra thuật toán
giải quyết nó? Trong chương này, chúng ta sẽ trình bày các chiến lược thiết
kế thuật toán, còn được gọi là các kỹ thuật thiết kế thuật toán. Mỗi chiến
lược này có thể áp dụng để giải quyết một phạm vi khá rộng các bài toán.
Mỗi chiến lược có các tính chất riêng và chỉ thích hợp cho một số dạng bài
toán nào đó. Chúng ta sẽ lần lượt trình bày các chiến lược sau: chia-để-trị
(divide-and-conquer), quy hoạch động (dynamic programming), quay lui
(backtracking) và tham ăn (greedy method). Trong mỗi chiến lược chúng ta
sẽ trình bày ý tưởng chung của phương pháp và sau đó đưa ra một số ví dụ
minh họa.
Cần nhấn mạnh rằng, ta không thể áp dụng máy móc một chiến lược
cho một vấn đề, mà ta phải phân tích kỹ vấn đề. Cấu trúc của vấn đề, các đặc
điểm của vấn đề sẽ quyết định chiến lược có khả năng áp dụng.
16.1 CHIA - ĐỂ - TRỊ
16.1.1 Phương pháp chung
Chiến lược thiết kế thuật toán được sử dụng rộng rãi nhất là chiến
lược chia-để-trị. Ý tưởng chung của kỹ thuật này là như sau: Chia vấn đề cần
giải thành một số vấn đề con cùng dạng với vấn đề đã cho, chỉ khác là cỡ
của chúng nhỏ hơn. Mỗi vấn đề con được giải quyết độc lập. Sau đó, ta kết
hợp nghiệm của các vấn đề con để nhận được nghiệm của vấn đề đã cho.
Nếu vấn đề con là đủ nhỏ có thể dễ dàng tính được nghiệm, thì ta giải quyết
nó, nếu không vấn đề con được giải quyết bằng cách áp dụng đệ quy thủ tục
trên (tức là lại tiếp tục chia nó thành các vấn đề con nhỏ hơn,…). Do đó, các
154
thuật toán được thiết kế bằng chiến lược chia-để-trị sẽ là các thuật toán đệ
quy.
Sau đây là lược đồ của kỹ thuật chia-để-trị:
DivideConquer (A,x)
// tìm nghiệm x của bài toán A.
{
if (A đủ nhỏ)
Solve (A);
else {
Chia bài toán A thành các bài toán con
A
1
, A
2
,…, A
m
;
for (i = 1; i <= m ; i ++)
DivideConquer (A
i
, x
i
);
Kết hợp các nghiệm x
i
của các bài toán con A
i
(i=1, …, m) để
nhận được nghiệm x của bài toán A;
}
}
“Chia một bài toán thành các bài toán con” cần được hiểu là ta thực
hiện các phép biến đổi, các tính toán cần thiết để đưa việc giải quyết bài toán
đã cho về việc giải quyết các bài toán con cỡ nhỏ hơn.
Thuật toán tìm kiếm nhị phân (xem mục 4.4.2) là thuật toán được thiết
kế dựa trên chiến lược chia-để-trị. Cho mảng A cỡ n được sắp xếp theo thứ
tự tăng dần: A[0] ≤ … ≤ A[n-1]. Với x cho trước, ta cần tìm xem x có chứa
trong mảng A hay không, tức là có hay không chỉ số 0 ≤ i ≤ n-1 sao cho A[i]
= x. Kỹ thuật chia-để-trị gợi ý ta chia mảng A[0…n-1] thành 2 mảng con cỡ
n/2 là A[0…k-1] và A[k+1…n-1], trong đó k là chỉ số đứng giữa mảng. So
sánh x với A[k]. Nếu x = A[k] thì mảng A chứa x và i = k. Nếu không, do
tính được sắp của mảng A, nếu x < A[k] ta tìm x trong mảng A[0…k-1], còn
nếu x > A[k] ta tìm x trong mảng A[k+1…n-1].
Thuật toán Tháp Hà Nội (xem mục 15.5), thuật toán sắp xếp nhanh
(QuickSort) và thuật toán sắp xếp hoà nhập (MergeSort) sẽ được trình bày
155
trong chương sau cũng là các thuật toán được thiết kế bởi kỹ thuật chia-để-
trị. Sau đây chúng ta đưa ra một ví dụ đơn giản minh hoạ cho kỹ thuật chia-
để-trị.
16.1.2 Tìm max và min
Cho mảng A cỡ n, chúng ta cần tìm giá trị lớn nhât (max) và nhỏ nhất
(min) của mảng này. Bài toán đơn giản này có thể giải quyết bằng các thuật
toán khác nhau.
Một thuật toán rất tự nhiên và đơn giản là như nhau. Đầu tiên ta lấy
max, min là giá trị đầu tiên A[0] của mảng. Sau đó so sánh max, min với
từng giá trị A[i], 1 ≤ i ≤ n-1, và cập nhật max, min một cách thích ứng.
Thuật toán này được mô tả bởi hàm sau:
SiMaxMin (A, max, min)
{
max = min = A[0];
for ( i = 1 ; i < n , i ++)
if (A[i] > max)
max = A[i];
else if (A[i] < min)
min = A[i];
}
Thời gian thực hiện thuật toán này được quyết định bởi số phép so
sánh x với các thành phần A[i]. Số lần lặp trong lệnh lặp for là n-1. Trong
trường hợp xấu nhất (mảng A được sắp theo thứ tự giảm dần), mỗi lần lặp ta
cần thực hiện 2 phép so sánh. Như vậy, trong trường hợp xấu nhất, ta cần
thực hiện 2(n-1) phép so sánh, tức là thời gian chạy của thuật toán là O(n).
Bây giờ ta áp dụng kỹ thuật chia-để-trị để đưa ra một thuật toán khác.
Ta chia mảng A[0 n-1] thành các mảng con A[0 k] và A[k+1 n-1] với k =
[n/2]. Nếu tìm được max, min của các mảng con A[0 k] và A[k+1 n-1], ta
dễ dàng xác định được max, min trên mảng A[0 n-1]. Để tìm max, min trên
156
mảng con ta tiếp tục chia đôi chúng. Quá trình sẽ dừng lại khi ta nhận được
mảng con chỉ có một hoặc hai phần tử. Trong các trường hợp này ta xác định
được dễ dàng max, min. Do đó, ta có thể đưa ra thuật toán sau:
MaxMin (i, j, max, min)
// Biến max, min ghi lại giá trị lớn nhất, nhỏ nhất trong mảng A[i j]
{
if (i = = j)
max = min = A[i];
else if (i = = j-1)
if (A[i] < A[j])
{
max = A[j];
min = A[i];
}
else {
max = A[i];
min = A[j];
}
else {
mid = (i+j) / 2;
MaxMin (i, mid, max1, min1);
MaxMin (mid + 1, j, max2, min2);
if (max 1< max2)
max = max2;
else max = max1;
if (min1 < min2)
min = min1;
else min = min2;
}
}
Bây giờ ta đánh giá thời gian chạy của thuật toán này. Gọi T(n) là số
phép so sánh cần thực hiện. Không khó khăn thấy rằng, T(n) được xác định
bởi quan hệ đệ quy sau.
T(1) = 0
T(2) = 1
157
T(n) = 2T(n/2) + 2 với n > 2
Áp dụng phương pháp thế lặp, ta tính được T(n) như sau:
T(n) = 2 T(n/2) + 2
= 2
2
T(n/2
2
) + 2
2
+ 2
= 2
3
T(n/2
3
) + 2
3
+ 2
2
+ 2
………
= 2
k
T(n/2
k
) + 2
k
+ 2
k-1
+… + 2
Với k là số nguyên dương sao cho 2
k
≤ n < 2
k+1
, ta có
T(n) = 2
k
T(1) + 2
k+1
– 2 = 2
k+1
– 2 ≤ 2(n-1)
Như vậy, T(n) = O(n).
16.2 THUẬT TOÁN ĐỆ QUY
Khi thiết kế thuật toán giải quyết một vấn đề bằng kỹ thuật chia-để-trị
thì thuật toán thu được là thuật toán đệ quy. Thuật toán đệ quy được biểu
diễn trong các ngôn ngữ lập trình bậc cao (chẳng hạn Pascal, C/C++) bởi các
hàm đệ quy: đó là các hàm chứa các lời gọi hàm đến chính nó. Trong mục
này chúng ta sẽ nêu lên các đặc điểm của thuật toán đệ quy và phân tích hiệu
quả (về không gian và thời gian) của thuật toán đệ quy.
Đệ quy là một kỹ thuật đặc biệt quan trọng để giải quyết vấn đề. Có
những vấn đề rất phức tạp, nhưng chúng ta có thể đưa ra thuật toán đệ quy
rất đơn giản, sáng sủa và dễ hiểu. Cần phải hiểu rõ các đặc điểm của thuật
toán đệ quy để có thể đưa ra các thuật toán đệ quy đúng đắn.
Giải thuật đệ quy cho một vấn đề cần phải thoả mãn các đòi hỏi sau:
1. Chứa lời giải cho các trường hợp đơn giản nhất của vấn đề. Các
trường hợp này được gọi là các trường hợp cơ sở hay các
trường hợp dừng.
2. Chứa các lời gọi đệ quy giải quyết các vấn đề con với cỡ nhỏ
hơn.
3. Các lời gọi đệ quy sinh ra các lời gọi đệ quy khác và về tiềm
năng các lời gọi đệ quy phải dẫn tới các trường hợp cơ sở.
158
Tính chất 3 là đặc biệt quan trọng, nếu không thoả mãn, hàm đệ quy
sẽ chạy mãi không dừng. Ta xét hàm đệ quy tính giai thừa:
int Fact(int n)
{
if (n = 0)
return 1;
else
return n * Fact(n-1); // gọi đệ quy.
}
Trong hàm đệ quy trên, trường hợp cơ sở là n = 0. Để tính Fact(n) cần thực
hiện lời gọi Fact(n-1), lời gọi này lại dẫn đến lời gọi F(n-2),…, và cuối cùng
dẫn tới lời gọi F(0), tức là dẫn tới trường hợp cơ sở.
Đệ quy và phép lặp. Đối với một vấn đề, có thể có hai cách giải: giải
thuật đệ quy và giải thuật dùng phép lặp. Giải thuật đệ quy được mô tả bởi
hàm đệ quy, còn giải thuật dùng phép lặp được mô tả bởi hàm chứa các lệnh
lặp, để phân biệt với hàm đệ quy ta sẽ gọi là hàm lặp. Chẳng hạn, để tính
giai thừa, ngoài hàm đệ quy ta có thể sử dụng hàm lặp sau:
int Fact(int n)
{
if (n = = 0)
return 1;
else {
int F= 1;
for (int i = 1; i <= n ; i + +)
F = F * i;
return F;
}
}
Ưu điểm nổi bật của đệ quy so với phép lặp là đệ quy cho phép ta đưa
ra giải thuật rất đơn giản, dễ hiểu ngay cả đối với những vấn đề phức tạp.
159
Trong khi đó, nếu không sử dụng đệ quy mà dùng phép lặp thì thuật toán
thu được thường là phức tạp hơn, khó hiểu hơn. Ta có thể thấy điều đó trong
ví dụ tính giai thừa, hoặc các thuật toán tìm kiếm, xem, loại trên cây tìm
kiếm nhị phân (xem mục 8.4). Tuy nhiên, trong nhiều trường hợp, các thuật
toán lặp lại hiệu quả hơn thuật toán đệ quy.
Bây giờ chúng ta phân tích các nhân tố có thể làm cho thuật toán đệ
quy kém hiệu quả. Trước hết, ta cần biết cơ chế máy tính thực hiện một lời
gọi hàm. Khi gặp một lời gọi hàm, máy tính tạo ra một bản ghi hoạt động
(activation record) ở ngăn xếp thời gian chạy (run-time stack) trong bộ nhớ
của máy tính. Bản ghi hoạt động chứa vùng nhớ cấp cho các tham biến và
các biến địa phương của hàm. Ngoài ra, nó còn chứa các thông tin để máy
tính trở lại tiếp tục hiện chương trình đúng vị trí sau khi nó đã thực hiện
xong lời gọi hàm. Khi hoàn thành thực hiện lời gọi hàm thì bản ghi họat
động sẽ bị loại bỏ khỏi ngăn xếp thời gian chạy.
Khi thực hiện một hàm đệ quy, một dãy các lời gọi hàm được sinh ra.
Hậu quả là một dãy bản ghi hoạt động được tạo ra trong ngăn xếp thời gian
chạy. Cần chú ý rằng, một lời gọi hàm chỉ được thực hiện xong khi mà các
lời gọi hàm mà nó sinh ra đã được thực hiện xong và do đó rất nhiều bản ghi
hoạt động đồng thời tồn tại trong ngăn xếp thời gian chạy, chỉ khi một lời
gọi hàm được thực hiện xong thì bản ghi hoạt động cấp cho nó mới được
loại ngăn xếp thời gian chạy. Chẳng hạn, xét hàm đệ quy tính giai thừa, nếu
thực hiện lời gọi hàm Fact(5) sẽ dẫn đến phải thực hiện các lời họi hàm
Fact(4), Fact(3), Fact(2), Fact(1), Fact(0). Chỉ khi Fact(4) đã được tính thì
Fact(5) mới được tính, … Do đó trong ngăn xếp thời gian chạy sẽ chứa các
bản ghi hoạt động như sau:
160
Bàn ghi hoạt động cho Fact(5)
Bàn ghi hoạt động cho Fact(4)
Bàn ghi hoạt động cho Fact(3)
Bàn ghi hoạt động cho Fact(2)
Bàn ghi hoạt động cho Fact(1)
Bàn ghi hoạt động cho Fact(0)
Trong đó, bản ghi hoạt động cấp cho lời gọi hàm Fact(0) ở đỉnh ngăn
xếp thời gian chạy. Khi thực hiện xong Fact(0) thì bản ghi hoạt động cấp cho
nó bị loại, rồi bản ghi hoạt động cho Fact(1) bị loại,…
Vì vậy, việc thực hiện hàm đệ quy có thể đòi hỏi rất nhiều không gian
nhớ trong ngăn xếp thời gian chạy, thậm chí có thể vượt quá khả năng của
ngăn xếp thời gian chạy trong bộ nhớ của máy tính.
Một nhân tố khác làm cho các thuật toán đệ quy kém hiệu quả là các
lời gọi đệ quy có thể dẫn đến phải tính nghiệm của cùng một bài toán con rất
nhiều lần. Số Fibonacci thứ n, ký hiệu là F(n), được xác định đệ quy như
sau:
F(1) = 1
F(2) = 1
F(n) = F(n-1) + F(n-2) với n>2
Do đó, ta có thể tính F(n) bởi hàm đệ quy sau.
int Fibo(int n)
{
if ((n = = 1) // (n = = 2))
return 1;
else
return Fibo (n-1) + Fibo(n-2);
}
Để tính F(7), các lời gọi trong hàm đệ quy Fibo dẫn ta đến phải tính
các F(k) vói k<7, như được biểu diễn bởi cây trong hình dưới đây; chẳng
hạn để tính F(7) cần tính F(6) và F(5), để tính F(6) cần tính F(5) và F(4), …
161
F(2)
F(7)
F(6) F(5)
F(5) F(4) F(4) F(3)
F(4) F(3) F(3) F(2) F(3) F(2) F(2) F(1)
F(3) F(2) F(2) F(1) F(1) F(2) F(1)
F(2) F(1)
Từ hình vẽ trên ta thấy rằng, để tính được F(7) ta phải tính F(5) 2 lần, tính
F(4) 3 lần, tính F(3) 5 lần, tính F(2) 8 lần và tính F(1) 5 lần. Chính sự kiện
để tính F(n) ta phải tính các F(k), với k<n, rất nhiều lần đã làm cho hàm đệ
quy Fibo kém hiệu quả. Có thể đánh giá thời gian chạy của nó là O(φ
n
),
trong đó = (1 +
5
)/2.
Chúng ta có thể đưa ra thuật toán lặp để tính dãy số Fibonacci. Ý
tưởng của thuật toán là ta tính lần lượt các F(1), F(2), F(3), …, F(n -2), F(n-
1), F(n) và sử dụng hai biến để lưu lại hai giá trị vừa tính. Hàm lặp tính dãy
số Fibonacci như sau:
int Fibo1(int n)
{
if ((n= = 1)//(n= = 2)
return 1;
else {
int previous = 1;
int current = 1;
for (int k = 3 ; k <= n ; k ++)
{
current + = previous;
previous = current – previous;
}
return current;
}
}
Dễ dàng thấy rằng, thời gian chạy của hàm lặp Fibo1 là O(n). Để tính
F(50) thuật toán lặp Fibo1 cần 1 micro giây, thuật toán đệ quy Fibo đòi hỏi
20 ngày, còn để tính F(100) thuật toán lặp cần 1,5 micro giây, trong khi
thuật toán đệ quy cần 10
9
năm!
Tuy nhiên, có rất nhiều thuật toán đệ quy cũng hiệu quả như thuật
toán lặp, chẳng hạn các thuật toán đệ quy tìm, xem, loại trên cây tìm kiếm
nhị phân (xem mục 8.4). Các thuật toán đệ quy: sắp xếp nhanh (QuickSort)
162
[...]... ra cách tính nghiệm của các bài toán con đơn giản nhất • Tìm ra các công thức (hoặc các quy tắc) xây dựng nghiệm của bài toán thông qua nghiệm của các bài toán con • Thiết kế bảng để lưu nghiệm của các bài toán con 163 • Tính nghiệm của các bài toán con từ nhỏ đến lớn và lưu vào bảng • Xây dựng nghiệm của bài toán từ bảng Một ví dụ đơn giản của thuật toán được thiết kế bằng quy hoạch động là thuật toán. .. bài toán con Thuật toán được thiết kế bằng kỹ thuật quy hoạch động sẽ là thuật toán lặp, trong khi thuật toán được thiết kế bằng kỹ thuật chia-để-trị là thuật toán đệ quy Để thuận tiện cho việc sử dụng lại nghiệm của các bài toán con, chúng ta lưu lại các nghiệm đã tính vào một bảng (thông thưòng là mảng 1 chiều hoặc 2 chiều) Tóm lại, để giải một bài toán bằng quy hoạch động, chúng ta cần thực hiện các. .. RandInt(i,j), trong đó i, j là các số nguyên và 0 . này, chúng ta sẽ trình bày các chiến lược thiết
kế thuật toán, còn được gọi là các kỹ thuật thiết kế thuật toán. Mỗi chiến
lược này có thể áp dụng để. O(n).
16.2 THUẬT TOÁN ĐỆ QUY
Khi thiết kế thuật toán giải quyết một vấn đề bằng kỹ thuật chia-để-trị
thì thuật toán thu được là thuật toán đệ quy. Thuật toán
Ngày đăng: 25/01/2014, 18:20
Xem thêm: Tài liệu Các chiến lược thiết kế thuật toán pptx, Tài liệu Các chiến lược thiết kế thuật toán pptx