Giải Thuật Và Lập Trình: §2. Phương Pháp Sinh (GENERATION)

• Đào tạo Độ tuổi từ 5 - 11 Độ tuổi từ 12 - 17 Từ 18 tuổi
• Lập trình Python Lập trình C C++ Java C# - C Sharp Android Scratch Pascal Robot mBot
• Web ReactJS HTML5 CSS3 JavaScript Node.js JSP ASP.NET Core jQuery PHP
• FW-CMS Laravel AngularJS Flutter Magento Bootstrap VueJS CodeIgnitor WordPress Sass Drupal
• Video Video Python Video Lập trình C Video C# Video Java Video HTML5-CSS3-JavaScript Video SQL Server Video PHP Video jQuery Video Android Video C++ Video Scratch
• Video1 Video XML-JSON Video MySQL Video Excel Video Giải thuật và Lập trình Video Sức khỏe Video Drupal Video mBot Video Giáo dục - Khoa học
• Other Unity Giải thuật và lập trình Giải thuật và lập trình - C CCNA Mạng máy tính Design Patterns English Facebook SEO Git Tin học đại cương Japanese App-Uti Download
• Data SQL Server XML JSON MySQL
• News

≡ ≡ Giải thuật và lập trình Phần 1: Bài toán liệt kê Lời mở đầu §1. Nhắc lại một số kiến thức đại số tổ hợp §2. Phương pháp sinh (GENERATION) §3. Thuật toán quay lui §4. Kỹ thuật nhánh cận Phần 2: Cấu trúc dữ liệu và giải thuật Lời mở đầu §1. Các bước cơ bản khi tiến hành giải các bài toán tin học §2. Phân tích thời gian thực hiện giải thuật §3. Đệ quy và giải thuật đệ quy §4. Cấu trúc dữ liệu biểu diễn danh sách §5. Ngăn xếp và hàng đợi §6. CÂY (TREE) §7. Ký pháp tiền tố, trung tố và hậu tố §8.1. Sắp xếp (SORTING) - Phần 1 §8.2. Sắp xếp (SORTING) - Phần 2 §9. Tìm kiếm (SEARCHING) Bài tập phần độ phức tạp giải thuật Bài tập phần Biểu diễn danh sách, Stack và Queue Phần 3: Quy hoạch động Lời mở đầu §1. Công thức truy hồi §2. Phương pháp quy hoạch động §3.1. Dãy con đơn điệu tăng dài nhất §3.2. Bài toán cái túi §3.3. Biến đổi xâu §3.4. Dãy con có tổng chia hết cho K §3.5. Phép nhân tổ hợp dãy ma trận §3.6. Bài tập luyện tập Phần 4: Các thuật toán trên đồ thị Lời mở đầu §1. Các khái niệm cơ bản §2. Biểu diễn đồ thị trên máy tính §3. Các thuật toán tìm kiếm trên đồ thị §4. Tính liên thông của đồ thị §5. Vài ứng dụng của các thuật toán tìm kiếm trên đồ thị §6. Chu trình Euler, đường đi Euler, đồ thị Euler §7. Chu trình Hamilton, đường đi Hamilton, đồ thị Hamilton §8. Bài toán đường đi ngắn nhất §9. Bài toán cây khung nhỏ nhất §10. Bài toán luồng cực đại trên mạng §11. Bài toán tìm bộ ghép cực đại trên đồ thị hai phía §12. Bài toán tìm bộ ghép cực đại với trọng số cực tiểu trên đồ thị hai phía. Thuật toán Hungari §13. Bài toán tìm bộ ghép cực đại trên đồ thị Giải thuật và lập trình: §2. Phương pháp sinh (GENERATION) Khóa học qua video: Lập trình Python All Lập trình C# All SQL Server All Lập trình C Java PHP HTML5-CSS3-JavaScript Đăng ký Hội viên Tất cả các video dành cho hội viên

Phương pháp sinh có thể áp dụng để giải bài toán liệt kê tổ hợp đặt ra nếu như hai điều kiện sau thoả mãn:

• Có thể xác định được một thứ tự trên tập các cấu hình tổ hợp cần liệt kê. Từ đó có thể biết đượccấu hình đầu tiên và cấu hình cuối cùng trong thứ tự đó.
• Xây dựng được thuật toán từ một cấu hình chưa phải cấu hình cuối, sinh ra được cấu hình kế tiếp nó.

Phương pháp sinh có thể mô tả như sau:

<Xây dựng cấu hình đầu tiên>;

repeat

<Đưa ra cấu hình đang có>;

<Từ cấu hình đang có sinh ra cấu hình kế tiếp nếu còn>;

until <hết cấu hình>;

Thứ tự từ điển

Trên các kiểu dữ liệu đơn giản chuẩn, người ta thường nói tới khái niệm thứ tự. Ví dụ trên kiểu số thì có quan hệ: 1 < 2; 2 < 3; 3 < 10; …, trên kiểu ký tự Char thì cũng có quan hệ 'A' < 'B'; 'C' < 'c'… Xét quan hệ thứ tự toàn phần "nhỏ hơn hoặc bằng" ký hiệu "≤" trên một tập hợp S, là quan hệ hai ngôi thoả mãn bốn tính chất:

Với mọi a, b, c ϵ S

Tính phổ biến: Hoặc là a ≤ b, hoặc b ≤ a;

Tính phản xạ: a ≤ a

Tính phản đối xứng: Nếu a ≤ b và b ≤ a thì bắt buộc a = b. Tính bắc cầu: Nếu có a ≤ b và b ≤ c thì a ≤ c.

Trong trường hợp a ≤ b và a ≠ b, ta dùng ký hiệu "<" cho gọn, (ta ngầm hiểu các ký hiệu như ≥, >, khỏi phải định nghĩa).

Ví dụ như quan hệ "≤" trên các số nguyên cũng như trên các kiểu vô hướng, liệt kê là quan hệ thứ tự toàn phần.

Trên các dãy hữu hạn, người ta cũng xác định một quan hệ thứ tự:

Xét a = (a1, a2, …, an) và b = (b1, b2, …, bn); trên các phần tử của a1, …, an, b1, …, bn đã có quan hệ thứ tự "≤". Khi đó a ≤ b nếu như:

Hoặc ai = bi với mọi i: 1 ≤ i ≤ n.

Hoặc tồn tại một số nguyên dương k: 1 ≤ k < n để:

a1 = b1

a2 = b2

…

ak-1 = bk-1

ak = bk

ak+1 < bk+1

Trong trường hợp này, ta có thể viết a < b.

Thứ tự đó gọi là thứ tự từ điển trên các dãy độ dài n.

Khi độ dài hai dãy a và b không bằng nhau, người ta cũng xác định được thứ tự từ điển. Bằng cách thêm vào cuối dãy a hoặc dãy b những phần tử đặc biệt gọi là phần tử Ø để độ dài của a và b bằng nhau, và coi những phần tử Ø này nhỏ hơn tất cả các phần tử khác, ta lại đưa về xác định thứ tự từ điển của hai dãy cùng độ dài. Ví dụ:

(1, 2, 3, 4) < (5, 6)

(a, b, c) < (a, b, c, d)

'calculator' < 'computer'

Sinh các cây nhị phân độ dài n

Một dãy nhị phân độ dài n là một dãy x = x1x2…xn trong đó xi ϵ {0, 1} (mọi i : 1 ≤ i ≤ n).

Dễ thấy: một dãy nhị phân x độ dài n là biểu diễn nhị phân của một giá trị nguyên p(x) nào đó nằm trong đoạn [0, 2n - 1]. Số các dãy nhị phân độ dài n = số các số nguyên ϵ [0, 2n - 1] = 2n. Ta sẽ lập chương trình liệt kê các dãy nhị phân theo thứ tự từ điển có nghĩa là sẽ liệt kê lần lượt các dãy nhị phân biểu diễn các số nguyên theo thứ tự 0, 1,…, 2n-1.

Ví dụ: Khi n = 3, các dãy nhị phân độ dài 3 được liệt kê như sau:

p(x)	0	1	2	3	4	5	6	7
x	000	001	010	011	100	101	110	111

Như vậy dãy đầu tiên sẽ là 00…0 và dãy cuối cùng sẽ là 11…1. Nhận xét rằng nếu dãy x = (x1, x2, …, xn) là dãy đang có và không phải dãy cuối cùng thì dãy kế tiếp sẽ nhận được bằng cách cộng thêm 1 ( theo cơ số 2 có nhớ) vào dãy hiện tại.

Ví dụ khi n = 8:

Dãy đang có:	10010000	Dãy đang có:	10010111
cộng thêm 1:	+ 1	cộng thêm 1:	+ 1
Dãy mới:	10010001	Dãy mới:	10011000

Như vậy kỹ thuật sinh cấu hình kế tiếp từ cấu hình hiện tại có thể mô tả như sau: Xét từ cuối dãy về đầu (xét từ hàng đơn vị lên), gặp số 0 đầu tiên thì thay nó bằng số 1 và đặt tất cả các phần tử phía sau vị trí đó bằng 0.

i := n;

while (i > 0) and (xi = 1) do i := i - 1;

if i > 0 then

begin

xi := 1;

for j := i + 1 to n do xj := 0;

end;

Dữ liệu vào (Input): nhập từ file văn bản BSTR.INP chứa số nguyên dương n ≤ 30 Kết quả ra (Output): ghi ra file văn bản BSTR.OUT các dãy nhị phân độ dài n.

BSTR.INP	BSTR.OUT
3	000
001
010
011
100
101
110
111

Giải thuật:

P_1_02_1.PAS * Thuật toán sinh liệt kê các dãy nhị phân độ dài n

program Binary_Strings;

const

InputFile = 'BSTR.INP';

OutputFile = 'BSTR.OUT';

max = 30;

var

x: array[1..max] of Integer;

n, i: Integer;

f: Text; begin

Assign(f, InputFile); Reset(f);

ReadLn(f, n);

Close(f);

Assign(f, OutputFile); Rewrite(f);

FillChar(x, SizeOf(x), 0); {Cấu hình ban đầu x1 = x2 = … = xn := 0}

repeat {Thuật toán sinh}

for i := 1 to n do Write(f, x[i]); {In ra cấu hình hiện tại}

WriteLn(f);

i := n; {xi là phần tử cuối dãy, lùi dần i cho tới khi gặp số 0 hoặc khi i = 0 thì dừng}

while (i > 0) and (x[i] = 1) do Dec(i);

if i > 0 then {Chưa gặp phải cấu hình 11…1}

begin

x[i] := 1; {Thay xi bằng số 1}

FillChar(x[i + 1], (n - i) * SizeOf(x[1]), 0); {Đặt xi + 1 = xi + 2 = … = xn := 0}

end;

until i = 0; {Đã hết cấu hình}

Close(f);

end.

Liệt kê các tập con k phần tử

Ta sẽ lập chương trình liệt kê các tập con k phần tử của tập {1, 2, …, n} theo thứ tự từ điền

Ví dụ: với n = 5, k = 3, ta phải liệt kê đủ 10 tập con:

1.{1, 2, 3} 2.{1, 2, 4} 3.{1, 2, 5} 4.{1, 3, 4} 5.{1, 3, 5}

6.{1, 4, 5} 7.{2, 3, 4} 8.{2, 3, 5} 9.{2, 4, 5} 10.{3, 4, 5}

Như vậy tập con đầu tiên (cấu hình khởi tạo) là {1, 2, …, k}. Cấu hình kết thúc là {n - k + 1, n - k + 2, …, n}.

Nhận xét: Ta sẽ in ra tập con bằng cách in ra lần lượt các phần tử của nó theo thứ tự tăng dần. Từ đó, ta có nhận xét nếu x = {x1, x2, …, xk} và x1 < x2 < … < xk thì giới hạn trên (giá trị lớn nhất có thể nhận) của xk là n, của xk-1 là n - 1, của xk-2 là n - 2, …

Cụ thể: giới hạn trên của xi = n - k + i;

Còn tất nhiên, giới hạn dưới của xi (giá trị nhỏ nhất xi có thể nhận) là xi-1 + 1.

Như vậy nếu ta đang có một dãy x đại diện cho một tập con, nếu x là cấu hình kết thúc có nghĩa là tất cả các phần tử trong x đều đã đạt tới giới hạn trên thì quá trình sinh kết thúc, nếu không thì ta phải sinh ra một dãy x mới tăng dần thoả mãn vừa đủ lớn hơn dãy cũ theo nghĩa không có một tập con k phần tử nào chen giữa chúng khi sắp thứ tự từ điển.

Ví dụ: n = 9, k = 6. Cấu hình đang có x = {1, 2, 6, 7, 8, 9}. Các phần tử x3 đến x6 đã đạt tới giới hạn trên nên để sinh cấu hình mới ta không thể sinh bằng cách tăng một phần tử trong số các x6, x5, x4, x3 lên được, ta phải tăng x2 = 2 lên thành x2 = 3. Được cấu hình mới là x = {1, 3, 6, 7, 8, 9}. Cấu hình này đã thoả mãn lớn hơn cấu hình trước nhưng chưa thoả mãn tính chất vừa đủ lớn,muốn vậy ta lại thay x3, x4, x5, x6 bằng các giới hạn dưới của nó. Tức là:

· x3 := x2 + 1 = 4

· x4 := x3 + 1 = 5

· x5 := x4 + 1 = 6

· x6 := x5 + 1 = 7

Ta được cấu hình mới x = {1, 3, 4, 5, 6, 7} là cấu hình kế tiếp. Nếu muốn tìm tiếp, ta lại nhận thấy rằng x6 = 7 chưa đạt giới hạn trên, như vậy chỉ cần tăng x6 lên 1 là được x = {1, 3, 4, 5, 6, 8}.

Vậy kỹ thuật sinh tập con kế tiếp từ tập đã có x có thể xây dựng như sau:

Tìm từ cuối dãy lên đầu cho tới khi gặp một phần tử xi chưa đạt giới hạn trên n - k + i.

i := n;

while (i > 0) and (xi = n - k + i) do i := i - 1; //(1, 2, 6, 7, 8, 9);

Nếu tìm thấy:

if i > 0 then

Tăng xi đó lên 1.

xi := xi + 1; //(1, 3, 6, 7, 8, 9)

Đặt tất cả các phần tử phía sau xi bằng giới hạn dưới:

for j := i + 1 to k do xj := xj-1 + 1; //(1, 3, 4, 5, 6, 7)

Input: file văn bản SUBSET.INP chứa hai số nguyên dương n, k (1 ≤ k ≤ n ≤ 30) cách nhau ít nhất một dấu cách.

Output: file văn bản SUBSET.OUT các tập con k phần tử của tập {1, 2, …, n}.

SUBSET.INP	SUBSET.OUT
5 3	{1, 2, 3}
{1, 2, 4}
{1, 2, 5}
{1, 3, 4}
{1, 3, 5}
{1, 4, 5}
{2, 3, 4}
{2, 3, 5}
{2, 4, 5}
{3, 4, 5}

Giải thuật:

P_1_02_2.PAS * Thuật toán sinh liệt kê các tập con k phần tử

program Combination; const

InputFile = 'SUBSET.INP';

OutputFile = 'SUBSET.OUT';

max = 30;

var

x: array[1..max] of Integer;

n, k, i, j: Integer;

f: Text; begin

Assign(f, InputFile); Reset(f);

ReadLn(f, n, k);

Close(f);

Assign(f, OutputFile); Rewrite(f);

for i := 1 to k do x[i] := i; {x1 := 1; x2 := 2; … ; xk := k (Cấu hình khởi tạo)}

repeat

{In ra cấu hình hiện tại}

Write(f, '{');

for i := 1 to k - 1 do Write(f, x[i], ', ');

WriteLn(f, x[k], '}');

{Sinh tiếp}

i := k; {xi là phần tử cuối dãy, lùi dần i cho tới khi gặp một xi chưa đạt giới hạn trên n - k + i}

while (i > 0) and (x[i] = n - k + i) do Dec(i);

if i > 0 then {Nếu chưa lùi đến 0 có nghĩa là chưa phải cấu hình kết thúc}

begin

Inc(x[i]); {Tăng xi lên 1, Đặt các phần tử đứng sau xi bằng giới hạn dưới của nó}

for j := i + 1 to k do x[j] := x[j - 1] + 1; end;

until i = 0; {Lùi đến tận 0 có nghĩa là tất cả các phần tử đã đạt giới hạn trên - hết cấu hình}

Close(f);

end.

Liệt kê các hoán vị

Ta sẽ lập chương trình liệt kê các hoán vị của {1, 2, …, n} theo thứ tự từ điển.

Ví dụ với n = 4, ta phải liệt kê đủ 24 hoán vị:

1.1234	2.1243	3.1324	4.1342	5.1423	6.1432
7.2134	8.2143	9.2314	10.2341	11.2413	12.2431
13.3124	14.3142	15.3214	16.3241	17.3412	18.3421
19.4123	20.4132	21.4213	22.4231	23.4312	24.4321

Như vậy hoán vị đầu tiên sẽ là (1, 2, …, n). Hoán vị cuối cùng là (n, n-1, … , 1).

Hoán vị sẽ sinh ra phải lớn hơn hoán vị hiện tại, hơn thế nữa phải là hoán vị vừa đủ lớn hơn hoán vị hiện tại theo nghĩa không thể có một hoán vị nào khác chen giữa chúng khi sắp thứ tự.

Giả sử hoán vị hiện tại là x = (3, 2, 6, 5, 4, 1), xét 4 phần tử cuối cùng, ta thấy chúng được xếp giảm dần, điều đó có nghĩa là cho dù ta có hoán vị 4 phần tử này thế nào, ta cũng được một hoán vị bé hơn hoán vị hiện tại!. Như vậy ta phải xét đến x2 = 2, thay nó bằng một giá trị khác. Ta sẽ thay bằng giá trị nào?, không thể là 1 bởi nếu vậy sẽ được hoán vị nhỏ hơn, không thể là 3 vì đã có x1 = 3 rồi (phần tử sau không được chọn vào những giá trị mà phần tử trước đã chọn). Còn lại các giá trị 4, 5, 6. Vì cần một hoán vị vừa đủ lớn hơn hiện tại nên ta chọn x2 = 4. Còn các giá trị (x3, x4, x5, x6) sẽ lấy trong tập {2, 6, 5, 1}. Cũng vì tính vừa đủ lớn nên ta sẽ tìm biểu diễn nhỏ nhất của 4 số này gán cho x3, x4, x5, x6 tức là (1, 2, 5, 6). Vậy hoán vị mới sẽ là (3, 4, 1, 2, 5, 6).

(3, 2, 6, 5, 4, 1) → (3, 4, 1, 2, 5, 6).

Ta có nhận xét gì qua ví dụ này: Đoạn cuối của hoán vị được xếp giảm dần, số x5 = 4 là số nhỏ nhất trong đoạn cuối giảm dần thoả mãn điều kiện lớn hơn x2 = 2. Nếu đổi chỗ x5 cho x2 thì ta sẽ được x2 = 4 và đoạn cuối vẫn được sắp xếp giảm dần. Khi đó muốn biểu diễn nhỏ nhất cho các giá trị trong đoạn cuối thì ta chỉ cần đảo ngược đoạn cuối.

Trong trường hợp hoán vị hiện tại là (2, 1, 3, 4) thì hoán vị kế tiếp sẽ là (2, 1, 4, 3). Ta cũng có thể coi hoán vị (2, 1, 3, 4) có đoạn cuối giảm dần, đoạn cuối này chỉ gồm 1 phần tử (4)

Vậy kỹ thuật sinh hoán vị kế tiếp từ hoán vị hiện tại có thể xây dựng như sau:

• Xác định đoạn cuối giảm dần dài nhất, tìm chỉ số i của phần tử xi đứng liền trước đoạn cuối đó. Điều này đồng nghĩa với việc tìm từ vị trí sát cuối dãy lên đầu, gặp chỉ số i đầu tiên thỏa mãn xi < xi+1. Nếu toàn dãy đã là giảm dần, thì đó là cấu hình cuối.

i := n - 1;

while (i > 0) and (xi > xi+1) do i := i - 1;

• Trong đoạn cuối giảm dần, tìm phần tử xk nhỏ nhất thoả mãn điều kiện xk > xi. Do đoạn cuối giảm dần, điều này thực hiện bằng cách tìm từ cuối dãy lên đầu gặp chỉ số k đầu tiên thoả mãn xk > xi (có thể dùng tìm kiếm nhị phân).

k := n;

while xk < xi do k := k - 1;

• Đổi chỗ xk và xi, lật ngược thứ tự đoạn cuối giảm dần (từ xi+1 đến xk) trở thành tăng dần.

Input: file văn bản PERMUTE.INP chứa số nguyên dương n ≤ 12

Output: file văn bản PERMUTE.OUT các hoán vị của dãy (1, 2, …, n)

PERMUTE.INP	PERMUTE.OUT
3	1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

Giải thuật:

P_1_02_3.PAS * Thuật toán sinh liệt kê hoán vị

program Permutation; const

InputFile = 'PERMUTE.INP';

OutputFile = 'PERMUTE.OUT';

max = 12;

var

n, i, k, a, b: Integer;

x: array[1..max] of Integer;

f: Text;

procedure Swap(var X, Y: Integer); {Thủ tục đảo giá trị hai tham biến X, Y}

var

Temp: Integer;

begin

Temp := X; X := Y; Y := Temp;

end;

begin

Assign(f, InputFile); Reset(f);

ReadLn(f, n);

Close(f);

Assign(f, OutputFile); Rewrite(f);

for i := 1 to n do x[i] := i; {Khởi tạo cấu hình đầu: x1 := 1; x2 := 2; …, xn := n}

repeat

for i := 1 to n do Write(f, x[i], ' '); {In ra cấu hình hoán vị hiện tại}

WriteLn(f); i := n - 1;

while (i > 0) and (x[i] > x[i + 1]) do Dec(i);

if i > 0 then {Chưa gặp phải hoán vị cuối (n, n-1, … ,1)}

begin

k := n; {xk là phần tử cuối dãy}

while x[k] < x[i] do Dec(k); {Lùi dần k để tìm gặp xk đầu tiên lớn hơn xi }

Swap(x[k], x[i]); {Đổi chỗ xk và xi}

a := i + 1; b := n; {Lật ngược đoạn cuối giảm dần, a: đầu đoạn, b: cuối đoạn}

while a < b do begin

Swap(x[a], x[b]); {Đổi chỗ xa và xb}

Inc(a); {Tiến a và lùi b, đổi chỗ tiếp cho tới khi a, b chạm nhau}

Dec(b); end;

end;

until i = 0; {Toàn dãy là dãy giảm dần - không sinh tiếp được - hết cấu hình}

Close(f);

end.

Bài tập

Bài 1

Các chương trình trên xử lý không tốt trong trường hợp tầm thường, đó là trường hợp n = 0 đối với chương trình liệt kê dãy nhị phân cũng như trong chương trình liệt kê hoán vị, trường hợp k = 0 đối với chương trình liệt kê tổ hợp, hãy khắc phục điều đó.

Bài 2

Liệt kê các dãy nhị phân độ dài n có thể coi là liệt kê các chỉnh hợp lặp chập n của tập 2 phần tử {0, 1}. Hãy lập chương trình:

Nhập vào hai số n và k, liệt kê các chỉnh hợp lặp chập k của {0, 1, …, n -1}.

Gợi ý: thay hệ cơ số 2 bằng hệ cơ số n.

Bài 3

Hãy liệt kê các dãy nhị phân độ dài n mà trong đó cụm chữ số "01" xuất hiện đúng 2 lần.

Bài 4.

Nhập vào một danh sách n tên người. Liệt kê tất cả các cách chọn ra đúng k người trong số n người đó.

Gợi ý: xây dựng một ánh xạ từ tập {1, 2, …, n} đến tập các tên người. Ví dụ xây dựng một mảng Tên: Tên[1] := 'Nguyễn văn A'; Tên[2] := 'Trần thị B';…. sau đó liệt kê tất cả các tập con k phần tử của tập {1, 2, …, n}. Chỉ có điều khi in tập con, ta không in giá trị số {1, 3, 5} mà thay vào đó sẽ in ra {Tên[1], Tên [3], Tên[5]}. Tức là in ra ảnh của các giá trị tìm được qua ánh xạ.

Bài 5

Liệt kê tất cả các tập con của tập {1, 2, …, n}. Có thể dùng phương pháp liệt kê tập con như trên hoặc dùng phương pháp liệt kê tất cả các dãy nhị phân. Mỗi số 1 trong dãy nhị phân tương ứng với một phần tử được chọn trong tập. Ví dụ với tập {1, 2, 3, 4} thì dãy nhị phân 1010 sẽ tương ứng với tập con {1, 3}. Hãy lập chương trình in ra tất cả các tập con của {1, 2, …, n} theo hai phương pháp.

Bài 6

Nhập vào danh sách tên n người, in ra tất cả các cách xếp n người đó vào một bàn.

Bài 7

Nhập vào danh sách n bạn nam và n bạn nữ, in ra tất cả các cách xếp 2n người đó vào một bàn tròn, mỗi bạn nam tiếp đến một bạn nữ.

Bài 8

Người ta có thể dùng phương pháp sinh để liệt kê các chỉnh hợp không lặp chập k. Tuy nhiên có một cách khác là liệt kê tất cả các tập con k phần tử của tập hợp, sau đó in ra đủ k! hoán vị của nó. Hãy viết chương trình liệt kê các chỉnh hợp không lặp chập k của {1, 2, …, n} theo cả hai cách.

Bài 9

Liệt kê tất cả các hoán vị chữ cái trong từ MISSISSIPPI theo thứ tự từ điển.

Bài 10

Liệt kê tất cả các cách phân tích số nguyên dương n thành tổng các số nguyên dương, hai cách phân tích là hoán vị của nhau chỉ tính là một cách.

Cuối cùng, ta có nhận xét, mỗi phương pháp liệt kê đều có ưu, nhược điểm riêng và phương pháp sinh cũng không nằm ngoài nhận xét đó. Phương pháp sinh không thể sinh ra được cấu hình thứ p nếu như chưa có cấu hình thứ p - 1, chứng tỏ rằng phương pháp sinh tỏ ra ưu điểm trong trường hợp liệt kê toàn bộ một số lượng nhỏ cấu hình trong một bộ dữ liệu lớn thì lại có nhược điểm và ít tính phổ dụng trong những thuật toán duyệt hạn chế. Hơn thế nữa, không phải cấu hình ban đầu lúc nào cũng dễ tìm được, không phải kỹ thuật sinh cấu hình kế tiếp cho mọi bài toán đều đơn giản như trên (Sinh các chỉnh hợp không lặp chập k theo thứ tự từ điển chẳng hạn). Ta sang một chuyên mục sau nói đến một phương pháp liệt kê có tính phổ dụng cao hơn, để giải các bài toán liệt kê phức tạp hơn đó là: Thuật toán quay lui (Back tracking).

Nguồn: Giáo trình Giải thuật và Lập trình - Lê Minh Hoàng - Đại học sư phạm Hà Nội » Tiếp: §3. Thuật toán quay lui « Trước: §1. Nhắc lại một số kiến thức đại số tổ hợp Khóa học qua video: Lập trình Python All Lập trình C# All SQL Server All Lập trình C Java PHP HTML5-CSS3-JavaScript Đăng ký Hội viên Tất cả các video dành cho hội viên Khóa học qua video: Lập trình Python All Lập trình C# All SQL Server All Lập trình C Java PHP HTML5-CSS3-JavaScript Đăng ký Hội viên Tất cả các video dành cho hội viên Copied !!! Copy linkCopied link!

Bạn muốn tìm kiếm điều gì?

×