1 / 22

Thiết kế thuật toán

Thiết kế thuật toán. 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ị”:

barclay-simpson
Download Presentation

Thiết kế thuật toán

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Thiết kế thuật toán

  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. 2014-11-13 Dao Thanh Tinh 2

  3. 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. 2014-11-13 Dao Thanh Tinh 3

  4. Phương pháp tuần tự 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 Dao Thanh Tinh 2014-11-13 4

  5. Phương pháp tuần tự 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) Dao Thanh Tinh 2014-11-13 5

  6. Phương pháp tuần tự 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) Dao Thanh Tinh 2014-11-13 6

  7. Phương pháp tuần tự x1 ... ≤ xi-1, xi, …., xn 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; Dao Thanh Tinh 2014-11-13 7

  8. 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 m2. 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 Dao Thanh Tinh

  9. 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]; Dao Thanh Tinh

  10. Divide and Conquer (3) • 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 Dao Thanh Tinh

  11. Divide and Conquer (4) 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: Dao Thanh Tinh

  12. Divide and Conquer (5) 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; Dao Thanh Tinh

  13. Divide and Conquer (6) 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; while ((j>d)&(Xj>tg)) { Xj=Xj-1; j=j-1; } Xj = tg; • Pc(Xd,...,Xc) • if (c>d) • Pc(Xd,...Xc-1); • j = c; tg = Xc; • while ((j>d)&(Xj>tg)) { Xj=Xj-1; j=j-1; } • Xj = tg; Dao Thanh Tinh

  14. Divide and Conquer (7) Pc(Xd,...,Xc) if (c>d) for k=d+1 to c j = k; tg = Xk; while ((j>d)&(Xj>tg)) { Xj=Xj-1; j=j-1; } Xj = tg; Insertion Sort • Pc(Xd,...,Xc) • for k=d+1 to c • j = k; tg = Xk; • while ((j>d)&(Xj>tg)) { Xj=Xj-1; j=j-1; } • Xj = tg; Dao Thanh Tinh

  15. Divide and Conquer (8) • 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); 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: Selection Sort • for k=d to c-1 xj =min{xk, ...,xc}; swap(xk, xj); Dao Thanh Tinh

  16. 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; } 2014-11-13 Dao Thanh Tinh 16

  17. Độ phức tạp tính toán (1) • 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; while ((j>d)&(Xj>tg)) { Xj=Xj-1; j=j-1; } Xj = tg; 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). Dao Thanh Tinh

  18. Độ phức tạp tính toán (2) 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 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]; 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 Dao Thanh Tinh

  19. Độ phức tạp tính toán (3) 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ử): • Số lá của cây quyết định là n! • Chiều cao bé nhất của cây là log2n! • Số phép so sánh bằng độ dài đường đi từ gốc đến lá kết quả. • log2n! < log2nn = nlog2n Dao Thanh Tinh

  20. Độ phức tạp tính toán (4) • 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); 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); • for k:= c downto d+1 • Đảo {xd,...,xk} sao cho xd = max{xd,...,xk}; • swap(xd, xk); Dao Thanh Tinh

  21. Độ phức tạp tính toán (5) • for k:= c downto d+1 • Đả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) Dao Thanh Tinh

  22. Bài tập 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. 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. Cho ma trận Amn 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. Dao Thanh Tinh

More Related