Thiết kế thuật toán

Thiết kế thuật toán

19.04.23 Dao Thanh Tinh 2

Tư tưởng tiếp cận

Phương pháp giải quyết tuần tự (gia tăng – incremental):

Giải quyết tuần tự từng bước theo một thứ tự nào đó cho đến bước cuối cùng, hoặc cho đến khi thực hiện xong yêu cầu (không nhất thiết đến bước cuối cùng)

Phương pháp “chia để trị”:

Chia bài toán đã cho thành các bài toán nhỏ hơn (phạm vi giải quyết, miền dữ liệu). Giải quyết các bài toán nhỏ, sau đó tổng hợp lại để có lời giải bài toán ban đầu.


Phương pháp tuần tự

Bài toán:

Cho dãy số

X = {x1, x2, …, xn} (1)

Sắp xếp X thành dãy không giảm:

x1 x2 …. xn (2)

Ý tưởng:

Bắt đầu từ đoạn có một (hoặc vài) phần tử, mở rộng dần đoạn được sắp cho đến khi toàn bộ dãy số được sắp xếp.



Ví dụ: Sắp xếp chọn, chèn, nổi bọt

Ở mỗi bước (thứ i, với i=1,2,..,n-1) sắp xếp đoạn từ x1, x2, ...., xi thành

đoạn không giảm:

x1 ... ≤ xi-1, xi, …., xn

Các trường hợp:

1) x1 ... ≤ xi-1 ≤ xj, với xj{xi, ..., xn}

2) x1 ... ≤ xi-1 không rõ quan hệ xj, j{i, ..., n} với đoạn đã

được sắp



x1 ... ≤ xi-1, xi, …., xn

1) x1 ... ≤ xi-1 ≤ xj, với xj{xi, ..., xn}

chọn xi = min {xi, ..., xn}

đoạn đã sắp được mở rộng x1 ... ≤ xi-1 ≤ xi

a) Sắp xếp chọn: chọn xk = min {xi, ..., xn}, đổi chỗ (xk,xi)

b) Sắp xếp nổi bọt: đổi chỗ các phần tử (từng cặp nghịch thế: xj-1 > xj)

để các phần tử bé được đưa dần lên trước, phần

tử bé nhất lên đầu

xi ≤ xj, xj{xi, ...., xn}

for j = n downto i+1

if (xj-1 > xj) đổi chỗ (xj-1,xj)



x1 ... ≤ xi-1, xi, …., xn

1) Giả thiết là đoạn đầu rỗng: i=1

a) Sắp xếp chọn:

for i=1 to n-1

chọn xk = min {xi, ..., xn}, đổi chỗ (xk,xi)

b) Sắp xếp nổi bọt:

for i=1 to n-1 for j = n downto i+1

if (xj-1 > xj) đổi chỗ (xj-1,xj)



x1 ... ≤ xi-1, xi, …., xn

2) x1 ... ≤ xi-1 không rõ quan hệ xj, j{i, ..., n} với đoạn đã được sắp

Sắp xếp chèn:

Xét đoạn mở rộng: x1, ..., xi-1, xi

cần sắp lại để sao cho: x1 ≤ ... xi-1 ≤ xi

a) {x1, ..., xi-1} ≤ xi

b) xi < {x1, ... , xi-1}

c) x1 < xi < xi-1

j = i; tg = xi;

while (j>1) & (tg < xj-1) {xj = xj-1; j=j-1;}

xj = tg;


Divide and Conquer (chia để trị)

Divide and Conquer là thuật toán được thiết kế tổng quát theo lược đồ:

Divide: Chia tập dữ liệu đầu vào S thành các tập con S1, S2, …, Sm. Với m2.

Recur: Giải đệ quy bài toán trên các tập dữ liệu con Si, i=1, 2, ..,m.

Conquer: Tổ hợp lời giải trên các tập dữ liệu con

S1, S2, …, Sm tạo lời giải bài toán trên tập S.

•Phân chia bài toán S ban đầu thành các bài toán con Si, i=1, …, m.•Giải đệ quy các bài toán con Si, i=1,…,m•Tổ hợp lời giải các bài toán con tạo lời giải bài toán S ban đầu


Divide and Conquer (2)

Ví dụ 1: MergeSort(xd, …, xc) if (c-d > 0) Divide: m := (d+c)/2; Chia S={xd, .., xc} thành 2 dãy con S1={xd, .., xm}, S2={xm+1,…xc} Recur: Giải đệ quy các bài toán con

MergeSort(xd,…,xm); MergeSort(xm+1,…,xc); Conquer:Tổ hợp lời giải từ {xd… xm} và {xm+1…xc}

i=d; j:=m+1; k:=d;while (i m) & (j c)

a) if xi < xj { zk := xi; i++}

else { zk := xj; j++}

b) k++;if (i>m) for t = j to c zk+t-j := xt;

else for t = i to m zk+t-i := xt;x[d..c] := z[d..c];



Remark:

– Divide form:

– Thủ tục divide khá phức tạp

– Thủ tục conquer thường là đơn giản

– Conquer form:

– Thủ tục divide khá đơn giản

– Thủ tục conquer thường là phức tạp



Ví dụ 2 (divide form): QuickSort(xd,…,xc)if (c-d > 0) Divide: M := xd; i:=d+1; j:=c;

while (i j)while (i j)&(xi M) i:=i+1;

while (i j)&(xj M) j:=j-1; if (i<j) swap(xi, xj);

swap(xd, xj);Các tập con S1={xd, .., xj-1}, S2={xj}, S3={xj+1,…xc} có tính chất, với a S1 và b S3:

a xj b Recur:

QuickSort(xd,…,xj-1); QuickSort(xj+1,…,xc);

Conquer:



Remark:Simple Divide:

Xét trường hợp X={Xd, …,Xc} được chia thành 2 phần X’={Xd,…,Xc-1} và X”={Xc}

Recur:

Sắp xếp X’ và X”

Conquer:

Vì X” có 1 phần tử nên có thể

sử dụng hòa nhập đơn giản

j = c; tg = Xc;

while ((j>d)&(Xj>tg))

{ Xj=Xj-1; j=j-1; }

Xj = tg;



Pc(Xd,...,Xc)Simple Divide:

X’={Xd,…,Xc-1}, X”={Xc}Recur:

Sắp xếp X’: Pc(Xd,...Xc-1);

Conquer:

j = c; tg = Xc;


{ Xj=Xj-1; j=j-1; }

Xj = tg;

Pc(Xd,...,Xc)if (c>d)

Pc(Xd,...Xc-1);

j = c; tg = Xc;


{ Xj=Xj-1; j=j-1; }

Xj = tg;



Pc(Xd,...,Xc)if (c>d)for k=d+1 to c

j = k; tg = Xk;


{ Xj=Xj-1; j=j-1; }

Xj = tg;

Pc(Xd,...,Xc)for k=d+1 to c

j = k; tg = Xk;


{ Xj=Xj-1; j=j-1; }

Xj = tg;

Insertion Sort



Divide form: QuickSort(xd,…,xc)

if (c-d > 0)

Divide: M := xd; i:=d+1; j:=c;

while (i j)while (i j)&(xi M) i:=i+1;

while (i j)&(xj M) j:=j-1;

if (i<j) swap(xi, xj);

swap(xd, xj);

Các tập con S1={xd, .., xj-1}, S2={xj}, S3={xj+1,…xc}

a S1 và b S3: a xj b

Recur: QuickSort(xd,…,xj-1);

QuickSort(xj+1,…,xc);

Conquer:

Divide form: QS2 (xd,…,xc)if (c-d > 0)Divide:

Find xj = min {Xd, ..., Xc}

swap(xd, xj);

Các tập con S2={xj}, S3={xj+1,…xc} a S2 và b S3: a b

Recur: QS2(xj+1,…,xc);

for k=d to c-1xj =min{xk, ...,xc};

swap(xk, xj);

Selection Sort


Ví dụ

Cho dãy số X={xd, xd+1, ..., xc}.

Tìm phần tử lớn nhất của dãy.

Tuần tự:Xét đến phần tử thứ i-1:

Tìm k, xk = max {xd, ..., xi-1}

Xét đến phần tử thứ i:if (xk < xi) k = i;

Thuật toán:k = d;for i=d+1 to c

if (xk<xi) k = i;

Chia để trị:Chia đoạn xd, xd+1, ..., xc làm 2 phần

xd, ..., xm và xm+1, ..., xc

Tìm xt = max{ xd, ..., xm}

xf = max{ xm+1, ..., xc}

if (xt > xf) k = t; else k = f;

Thuật toán:int max(chỉ số d, c)

if (d==c) return d;else

{ m= (d+c)/2; t = max(d,m); f=max(m+1,c);

if (xt>xf) return t;

else return f;}


Độ phức tạp tính toán (1)

Insertion Sort (X1,...,Xn)for k=2 to n

j = k; tg = Xk;

while ((j>d)&(Xj>tg)) { Xj=Xj-1; j=j-1; }

Xj = tg;

Conquer(k) trong trường hợp xấu nhất là O(k), k=2, ..., n.Tổng thể, Insertion Sort có độ phức tạp về thời gian là O(n2).

Insertion Sort (từ Divide and Conquer)

Pc(Xd,...,Xc)Simple Divide:

X’={Xd,…,Xc-1}, X”={Xc}Recur:

Sắp xếp X’: Pc(Xd,...Xc-1);

Conquer:

j = c; tg = Xc;


{ Xj=Xj-1; j=j-1; }

Xj = tg;



MergeSort(xd, …, xc)if (c-d > 0) m := (d+c)/2;

MergeSort(xd,…,xm); MergeSort(xm+1,…,xc);i=d; j:=m+1; k:=d;while (i m) & (j c)a) if xi < xj { zk := xi; i++}else { zk := xj; j++}b) k++;if (i>m) for t = j to c zk+t-j := xt;else for t = i to m zk+t-i := xt;x[d..c] := z[d..c];

Ký hiệu T(n) là hàm thời gian của thuật toán. T(1) = 1.T(n) = 2T(n/2) + n

T(n) =2T(n/2)+n

=2{2T(n/4)+n/2} + n

= 22T(n/22) + 2n/2 + n

=22{2T(n/23) + n/22} + 2n

=23T(n/23) + 3n

= ....

=2kT(n/2k) + kn.

k>log2n => n/2k <1.

=> T(n) n.log2n



Comparison-based sorting algorithms đạt giới hạn (về lý thuyết) là O(nlogn).

Xét cây nhị phân quyết định (mỗi phép so sánh quyết định tới việc di chuyển một phần tử):

o Số lá của cây quyết định là n!o Chiều cao bé nhất của cây là log2n!o Số phép so sánh bằng độ dài đường đi từ gốc

đến lá kết quả.o log2n! < log2nn = nlog2n



Heap Sort(xd,...,xc);Find xj = max {xd,...,xc}

swap(xj, xc);

HeapSort(xd,...,xc-1); Viết lại:

for k:= c downto d+1

Find xj = max {xd,...,xk};

swap(xj, xk);

Divide form: QS2 (xd,…,xc)if (c-d > 0)Divide:

Find xj = min {xd, ..., xc}

swap(xd, xj);

Các tập con S2={xj}, S3={xj+1,…xc} a S2 và b S3: a b

Recur: QS2(xj+1,…,xc);


Đảo {xd,...,xk} sao cho xd = max{xd,...,xk};

swap(xd, xk);




Đảo {xd,...,xk} sao cho xd = max{xd,...,xk};

swap(xd, xk);

Giả thiết {xd,...,xk} là heap: xt max{x2t,x2t+1},

t = d,...,k/2; xd = max{xd,...,xk}

Tổ chức H = {temp = xk, xd+1, ..., xk-1} thành heap:a) t = d;b) if (2t k-1)

j=2t; if (j<k-1)&(xj+1>xj) j=j+1;

if (temp <xj) {swap(xt,xj); t:=j; goto b);}

Số bước vòng lặp b) bằng log2(k-d)

Suy ra dộ phức tạp của thuật toán vun đống là:(c-d)log2(c-d) hay

O(nlogn)


Bài tập

1. Có 1000 phiếu thu tiền điện thoại và 1000 biên lai thu tiền (trong đó có ghi số điện thoại của thuê bao). Cần xác định có hay không người chưa trả tiền.

2. Cho một danh sách gồm tên sách, tác giả, số điện thoại và nhà xuất bản tất cả sách trong thư viện và một danh sách khác khoảng 30 nhà xuất bản. Tính số sách có trong thư viện của mỗi nhà xuất bản.

3. Cho ma trận Amn trong đó các phần tử trên từng cột, hàng đã được sắp xếp không giảm. Cho giá trị x, xác định có hay không một phần tử của A bằng x. Đánh giá số phép so sánh phải thực hiện.

Documents

Thiết kế thuật toán