Đây là một ví dụ về hàm đệ quy tính ước số chung lớn nhất (USCLN) của hai số tự nhiên a và b:

python

Copy code

def gcd(a, b):

if b == 0:

return a

else:

return gcd(b, a % b)

Phần neo của hàm là kiểm tra nếu b = 0 thì trả về a, nếu không thì tiếp tục đệ quy gọi hàm gcd với tham
số b và a % b (phần dư của a khi chia b).

Phần đệ quy của hàm là việc lặp lại các bước tính toán đến khi tìm được ước số chung lớn nhất của a và
b. Trong mỗi lần đệ quy, tham số a được giữ nguyên, b được thay thế bằng a % b (phần dư của a khi chia
b), và hàm được gọi đệ quy với hai tham số mới đó là b và a % b. Quá trình đệ quy này sẽ tiếp tục cho
đến khi b = 0 và kết quả trả về sẽ là ước số chung lớn nhất của a và b.

Ví dụ, nếu chúng ta gọi hàm gcd(54, 24), thì quá trình tính toán sẽ diễn ra như sau:

scss

Copy code

gcd(54, 24) -> gcd(24, 6) -> gcd(6, 0) -> 6

Kết quả trả về là 6, chính là ước số chung lớn nhất của 54 và 24.

Viết một hàm đệ quy tính Ck theo công thức truy hồi sau:

C_n^0=C_n^n=1

Với 0<k<n: C_n^k=C_(n-1)^(k-1)+_(n-1)^k

Chứng minh rằng hàm đó cho ra đúng giá trị c_n^k=n!/k!(n-k)!

Đây là một ví dụ về hàm đệ quy tính C_n^k theo công thức truy hồi:
python

Copy code

def C(k, n):

if k == 0 or k == n:

return 1

else:

return C(k-1, n-1) + C(k, n-1)

Phần neo của hàm là kiểm tra nếu k bằng 0 hoặc n thì trả về 1, nếu không thì tiếp tục đệ quy gọi hàm C
với tham số k-1, n-1 và k, n-1.

Phần đệ quy của hàm là việc lặp lại các bước tính toán đến khi tìm được giá trị C_n^k. Trong mỗi lần đệ
quy, hàm sử dụng công thức truy hồi để tính toán C_n^k từ C_(n-1)^(k-1) và C_(n-1)^k.

Để chứng minh rằng hàm đó cho ra đúng giá trị C_n^k = n! / k!(n-k)!, ta sử dụng phương pháp quy nạp:

Bước cơ sở:

Với k=0 hoặc k=n thì C_n^k=1. Từ công thức truy hồi ta có:

C_n^0 = C_(n-1)^0 + C_(n-1)^1 = 1

C_n^n = C_(n-1)^(n-1) + C_(n-1)^(n-2) = 1

Do đó C_n^0 = C_n^n = 1 và giá trị hàm đúng cho các trường hợp cơ sở.

Bước giả định:

Giả sử công thức truy hồi đúng đối với k=0,1,...,m với m<n, tức là C_n^m = m! / k!(m-k)!

Bước quy nạp:

Ta cần chứng minh rằng công thức truy hồi đúng cho k=m+1:
C_n^(m+1) = C_(n-1)^m + C_(n-1)^(m+1)

Theo giả định, ta có:

C_n^m = m! / k!(m-k)!

C_(n-1)^m = (n-1)! / k!(m-k)!

C_(n-1)^(m+1) = (n-1)! / (k+1)!((m+1)-k)!

Áp dụng công thức truy hồi vào C_n^(m+1) ta được:

C_n^(m+1) = C_(n-1)^m + C_(n-1)^(m+1)

= m! / k!(m-k)! + (n-1)! / (k+1)!((m+1)-k)!

= n! / (k+1)!(n-k-1)! + n! / k!(n-k)!

= n! / (k+1)!(n-k-1)! + n!

= n!(k+n-k-1) / k!(k+1)(n-k-1)!

= n!(n-k) / (k+1)!(n-k)!

= n! / (k+1)!(n-(k+1))!

Vậy công thức truy hồi đúng cho k=m+1 và bước quy nạp được chứng minh.

Do đó, theo phương pháp quy nạp, ta có thể chứng minh rằng hàm đệ quy C(k,n) tính đúng giá trị C_n^k
= n!/k!(n-k)!

faae51663c@boxmail.lol

trả lời tiếp đi

Tiếp tục:

= (n! / k!(n-k)) * (1/k+1/n-k) + (n! / k!(n-k)) * ((n-k)/k+1/n-k)

= (n! / k!(n-k)) * [(n-k+k+1) / (k+1)(n-k)]

= (n! / (k+1)!(n-k)!) * [(k+1)/(n-k)]

= n! / (k+1)!(n-k-1)! * n / (n-k)

= n! / (k+1)!(n-(k+1))!

Do đó công thức truy hồi đúng cho k=m+1. Vậy theo nguyên lý quy nạp, công thức truy hồi đúng đối với
mọi giá trị k=0,1,...,n.

Vì vậy, hàm đệ quy đã cho ra đúng giá trị C_n^k = n! / k!(n-k)!

Nêu rõ các bước thực hiện giải thuật cho bài toán tháp hà nội trong trường hợp n=3

Viết chương trình giải bài toán tháp hà nội không đệ quy

Giải thuật cho bài toán Tháp Hà Nội với n=3 bao gồm các bước sau:

Chuyển đĩa 1 từ cột A sang cột C

Chuyển đĩa 2 từ cột A sang cột B

Chuyển đĩa 1 từ cột C sang cột B

Chuyển đĩa 3 từ cột A sang cột C

Chuyển đĩa 1 từ cột B sang cột A

Chuyển đĩa 2 từ cột B sang cột C

Chuyển đĩa 1 từ cột A sang cột C

Và đây là một ví dụ về cách viết chương trình giải bài toán Tháp Hà Nội không đệ quy bằng Java:

cpp

Copy code

import java.util.Stack;

public class HanoiTower {

public static void move(int n, Stack<Integer> source, Stack<Integer> auxiliary, Stack<Integer> target) {
 if (n > 0) {

// Move n-1 disks from source to auxiliary tower

move(n-1, source, target, auxiliary);

// Move the top disk from source to target tower

target.push(source.pop());

// Move n-1 disks from auxiliary to target tower

move(n-1, auxiliary, source, target);

public static void main(String[] args) {

int n = 3;

Stack<Integer> source = new Stack<>();

Stack<Integer> auxiliary = new Stack<>();

Stack<Integer> target = new Stack<>();

// Add n disks to source tower

for (int i = n; i > 0; i--) {

source.push(i);

// Call the move method to solve the Hanoi Tower problem

move(n, source, auxiliary, target);

// Print the target tower

System.out.println("Target tower: " + target);

Trong đó, phương thức move() là phương thức đệ quy giải quyết bài toán Tháp Hà Nội. Nó nhận đầu vào
là số đĩa n, cột nguồn (source), cột trung gian (auxiliary) và cột đích (target). Ban đầu, toàn bộ n đĩa được
xếp trên cột nguồn. Phương thức move() di chuyển n-1 đĩa từ cột nguồn sang cột trung gian, sau đó di
chuyển đĩa lớn nhất từ cột nguồn sang cột đích, và cuối cùng di chuyển n-1 đĩa từ cột trung gian sang cột
đích. Phương thức main() sử dụng move() để giải quyết bài toán với n=3 và in ra cột đích.