01/10/2018, 22:17

[Thuật toán]Cách tính độ phức tạp thuật toán – Algorithm complexity

[Thuật toán]Cách tính độ phức tạp thuật toán – Algorithm complexity Tháng Bảy 23, 2014 nguyenvanquan7826 Thuật toán 6 responses Nội dung Sự cần thiết phải phân tích thuật toán Thời gian thực hiện của chương trình Tỷ suất ...

[Thuật toán]Cách tính độ phức tạp thuật toán – Algorithm complexity

Tháng Bảy 23, 2014 nguyenvanquan7826 Thuật toán 6 responses

Nội dung
Sự cần thiết phải phân tích thuật toán
Thời gian thực hiện của chương trình
Tỷ suất gia tăng và độ phức tạp thuật toán
Cách tính độ phức tạp giải thuật
Giải phương trình đệ quy

Update ngày 28/05/2014 – Sửa chính tả và trình bày công thức toán một cách dễ nhìn hơn.
Có rất nhiều vấn đề xung quanh các giải thuật, đặc biệt là độ phức tạp thuật toán. Bài viết này sẽ đặt vấn đề, trình bày các khái niệm liên quan và các cách tích độ phức tạp của một giải thuật.
Bài viết có tham khảo ở Giáo trình phân tích giải thuật – ĐH Cần Thơ

I. SỰ CẦN THIẾT PHẢI PHÂN TÍCH THUẬT TOÁN

Trong khi giải một bài toán chúng ta có thể có một số giải thuật khác nhau, vấn đề là cần phải đánh giá các giải thuật đó để lựa chọn một giải thuật tốt (nhất). Thông thường thì ta sẽ căn cứ vào các tiêu chuẩn sau:
1. Giải thuật đúng đắn.
2. Giải thuật đơn giản.
3. Giải thuật thực hiện nhanh.

Với yêu cầu (1), để kiểm tra tính đúng đắn của giải thuật chúng ta có thể cài đặt giải thuật đó và cho thực hiện trên máy với một số bộ dữ liệu mẫu rồi lấy kết quả thu được so sánh với kết quả đã biết. Thực ra thì cách làm này không chắc chắn bởi vì có thể giải thuật đúng với tất cả các bộ dữ liệu chúng ta đã thử nhưng lại sai với một bộ dữ liệu nào đó. Vả lại cách làm này chỉ phát hiện ra giải thuật sai chứ chưa chứng minh được là nó đúng. Tính đúng đắn của giải thuật cần phải được chứng minh bằng toán học. Tất nhiên điều này không đơn giản và do vậy chúng ta sẽ không đề cập đến ở đây.
Khi chúng ta viết một chương trình để sử dụng một vài lần thì y ê u cầu (2) là quan trọng nhất. Chúng ta cần một giải thuật dễ viết chương trình để nhanh chóng có được kết quả, thời gian thực hiện chương trình không được đề cao vì dù sao thì chương trình đó cũng chỉ sử dụng một vài lần mà thôi.
Tuy nhiên khi một chương trình được sử dụng nhiều lần thì thì yêu cầu tiết kiệm thời gian thực hiện chương trình lại rất quan trọng đặc biệt đối với những chương trình mà khi thực hiện cần dữ liệu nhập lớn do đó yêu cầu (3) sẽ được xem xét một cách kĩ càng. Ta gọi nó là hiệu quả thời gian thực hiện của giải thuật.

II. THỜI GIAN THỰC HIỆN CỦA CHƯƠNG TRÌNH

Một phương pháp để xác định hiệu quả thời gian thực hiện của một giải thuật là lập trình nó và đo lường thời gian thực hiện của hoạt động trên một máy tính xác định đối với tập hợp được chọn lọc các dữ liệu vào. Thời gian thực hiện không chỉ phụ thuộc vào giải thuật mà còn phụ thuộc vào tập các chỉ thị của máy tính, chất lượng của máy tính và kĩ xảo của người lập trình. Sự thi hành cũng có thể điều chỉnh để thực hiện tốt trên tập đặc biệt các dữ liệu vào được chọn. Ðể vượt qua các trở ngại này, các nhà khoa học máy tính đã chấp nhận tính phức tạp của thời gian được tiếp cận như một sự đo lường cơ bản sự thực thi của giải thuật. Thuật ngữ tính hiệu quả sẽ đề cập đến sự đo lường này và đặc biệt đối với sự phức tạp thời gian trong trường hợp xấu nhất.
Thời gian thực hiện chương trình.
Thời gian thực hiện một chương trình là một hàm của kích thước dữ liệu vào, ký hiệu T(n) trong đó n là kích thước (độ lớn) của dữ liệu vào. Chương trình tính tổng của n số có thời gian thực hiện là T(n) = cn trong đó c là một hằng số. Thời gian thực hiện chương trình là một hàm không âm, tức là T(n) ≥ 0 với mọi n ≥ 0.
Ðơn vị đo thời gian thực hiện.
Ðơn vị của T(n) không phải là đơn vị đo thời gian bình thường như giờ, phút giây… mà thường được xác định bởi số các lệnh được thực hiện trong một máy tính lý tưởng. Khi ta nói thời gian thực hiện của một chương trình là T(n) = Cn thì có nghĩa là chương trình ấy cần Cn chỉ thị thực thi.
Thời gian thực hiện trong trường hợp xấu nhất.
Nói chung thì thời gian thực hiện chương trình không chỉ phụ thuộc vào kích thước mà còn phụ thuộc vào tính chất của dữ liệu vào. Nghĩa là dữ liệu vào có cùng kích thước nhưng thời gian thực hiện chương trình có thể khác nhau. Chẳng hạn chương trình sắp xếp dãy số nguyên tăng dần, khi ta cho vào dãy có thứ tự thì thời gian thực hiện khác với khi ta cho vào dãy chưa có thứ tự, hoặc khi ta cho vào một dãy đã có thứ tự tăng thì thời gian thực hiện cũng khác so với khi ta cho vào một dãy đã có thứ tự giảm. Vì vậy thường ta coi T(n) là thời gian thực hiện chương trình trong trường hợp xấu nhất trên dữ liệu vào có kích thước n, tức là: T(n) là thời gian lớn nhất để thực hiện chương trình đối với mọi dữ liệu vào có cùng kích thước n.

III. TỶ SUẤT GIA TĂNG VÀ ĐỘ PHỨC TẠP CỦA GIẢI THUẬT

Tỷ suất tăng
Ta nói rằng hàm không âm T(n) có tỷ suất tăng (growth rate) f(n) nếu $exists C, N_{0} | T(n) leq Cf(n), forall n geq N_{0}.$
Ta có thể chứng minh được rằng Cho một hàm không âm T(n) bất kỳ, ta luôn tìm được tỷ suất tăng f(n) của nó.
Giả sử T(0) = 1, T(1) = 4 và tổng quát: $T(n) = (n+1)^{2}$ .
Ðặt $N_{0} = 1, C = 4$ thì với mọi n ≥1 chúng ta dễ dàng chứng minh được rằng:
$T(n) = (n+1)^{2} leqslant 4n^{2}, forall n geq 1$ , tức là tỷ suất tăng của $T(n) = n^{2}$ .
Tỷ suất tăng của hàm T(n) = 3n^3 + 2n^2 = n^3 .
Thực vậy, cho $N_{0} = 0, C = 5$ ta dễ dàng chứng minh rằng $forall n geq 0 Rightarrow 3n^3 + 2n^2 leqslant 5n^{3}$
Khái niệm độ phức tạp của giải thuật
Giả sử ta có hai giải thuật P1 và P2 với thời gian thực hiện tương ứng là:
$egin{cases} T1(n) = 100n^2 & ext{ ty suat tang la } n^2 \ T2(n) = 5n^3 & ext{ty suat tang la } n^3 end{cases}$
Giải thuật nào sẽ thực hiện nhanh hơn? Câu trả lời phụ thuộc vào kích thước dữ liệu vào. Với n < 20 thì P2 sẽ nhanh hơn P1 (T2<T1), do hệ số của 5n^3 nhỏ hơn hệ số của 100n^2 (5<100). Nhưng khi n > 20 thì ngược lại do số mũ của 100n^2 nhỏ hơn số mũ của 5n^3 (2<3). Ở đây chúng ta chỉ nên quan tâm đến trường hợp n>20 vì khi n<20 thì thời gian thực hiện của cả P1 và P2 đều không lớn và sự khác biệt giữa T1 và T2 là không đáng kể.
Như vậy một cách hợp lý là ta xét tỷ suất tăng của hàm thời gian thực hiện chương trình thay vì xét chính bản thân thời gian thực hiện.
Cho một hàm T(n), T(n) gọi là độ phức tạp f(n) nếu $exists C, N_{0} | T(n) leq Cf(n), forall n geq N_{0}.$ (tức là T(n) có tỷ suất gia tăng là f(n)) và ký hiệu là O(f(n)). (“ô của f(n)”)
T(n)= (n+1)^2 có tỷ suất tăng là n^2 nên T(n) = O(n^2)
Chú ý: O(C.f(n))=O(f(n)) với C là hằng số. Ðặc biệt O(C) = O(1)

Nói cách khác độ phức tạp tính toán của giải thuật là một hàm chặn trên của hàm thời gian. Vì hằng nhân tử C trong hàm chặn trên không có ý nghĩa nên ta có thể bỏ qua vì vậy hàm thể hiện độ phức tạp có các dạng thường gặp sau:
logn, n, n^2, n^3, 2^n, n!m n^n .
Ba hàm cuối cùng ta gọi là dạng hàm mũ, các hàm khác gọi là hàm đa thức. Một giải thuật mà thời gian thực hiện có độ phức tạp là một hàm đa thức thì chấp nhận được tức là có thể cài đặt để thực hiện, còn các giải thuật có độ phức tạp hàm mũ thì phải tìm cách cải tiến giải thuật.
Chú ý: trong logn ta không cần quan tâm cơ số của nó vì $log_{a}n = log_{a}b.log_{b}n = log_{b}n, b > 0$ (Quy tắc bỏ hệ số sẽ đề cập sau)
Khi nói đến độ phức tạp của giải thuật là ta muốn nói đến hiệu quả của thời gian thực hiện của chương trình nên ta có thể xem việc xác định thời gian thực hiên của chương trình chính là xác định độ phức tạp của giải thuật.

IV. CÁCH TÍNH ĐỘ PHỨC TẠP GIẢI THUẬT

Cách tính độ phức tạp của một giải thuật bất kỳ là một vấn đề không đơn giản. Tuy nhiên ta có thể tuân theo một số nguyên tắc sau:
Quy tắc bỏ hằng số
Nếu đoạn chương trình P có thời gian thực hiện T(n) = O(c1.f(n)) với c1 là một hằng số dương
thì có thể coi đoạn chương trình đó có độ phức tạp tính toán là O(f(n)).
Quy tắc cộng – lấy max
Nếu T1(n) và T2(n) là thời gian thực hiện của hai đoạn chương trình P1 và P2; và T1(n)=O(f(n)), T2(n)=O(g(n)) thì thời gian thực hiện của đoạn hai chương trình đó nối tiếp nhau là T(n)=O(max(f(n),g(n)))
VD:
Lệnh gán x:=15 tốn một hằng thời gian hay O(1), Lệnh đọc dữ liệu readln(x) tốn một hằng thời gian hay O(1).
Vậy thời gian thực hiện cả hai lệnh trên nối tiếp nhau là O(max(1,1))=O(1)
Quy tắc nhân
Nếu T1(n) và T2(n) là thời gian thực hiện của hai đoạn chương trình P1và P2 và T1(n) = O(f(n)), T2(n) = O(g(n)) thì thời gian thực hiện của đoạn hai đoạn chương trình đó lồng nhau là T(n) = O(f(n).g(n))
Quy tắc tổng quát để phân tích một chương trình
– Thời gian thực hiện của mỗi lệnh gán, READ, WRITE là O(1).
– Thời gian thực hiện của một chuỗi tuần tự các lệnh được xác định bằng qui tắc cộng. Như vậy thời gian này là thời gian thi hành một lệnh nào đó lâu nhất trong chuỗi lệnh.
– Thời gian thực hiện cấu trúc IF là thời gian lớn nhất thực hiện lệnh sau THEN hoặc sau ELSE và thời gian kiểm tra điều kiện. Thường thời gian kiểm tra điều kiện là O(1).
– Thời gian thực hiện vòng lặp là tổng (trên tất cả các lần lặp) thời gian thực hiện thân vòng lặp. Nếu thời gian thực hiện thân vòng lặp không đổi thì thời gian thực hiện vòng lặp là tích của số lần lặp với thời gian thực hiện thân vòng lặp.
VD: Tính thời gian thực hiện của thủ tục sắp xếp “nổi bọt”

procedure Bubble (var a: array[1..n] of integer);
var i,j,temp: integer;
begin
	for i:=1 to n-1 do					{1}
		for j:=n downto i+1 do				{2}
			if a[j-1]>a[j] then			{3}
			begin
				temp:=a[j-1];			{4}
				a[j-1]:=a[j];			{5}
				a[j]:=temp; 			{6}
			end;
end;

Về giải thuật sắp xếp nổi bọt, chúng ta sẽ bàn kĩ hơn trong chương 2. Ở đây, chúng ta chỉ quan tâm đến độ phức tạp của giải thuật.
Ta thấy toàn bộ chương trình chỉ gồm một lệnh lặp {1}, lồng trong lệnh {1} là lệnh {2}, lồng trong lệnh {2} là lệnh {3} và lồng trong lệnh {3} là 3 lệnh nối tiếp nhau {4}, {5} và {6}. Chúng ta sẽ tiến hành tính độ phức tạp theo thứ tự từ trong ra.
Trước hết, cả ba lệnh gán {4}, {5} và {6} đều tốn O(1) thời gian, việc so sánh a[j-1] > a[j] cũng tốn O(1) thời gian, do đó lệnh {3} tốn O(1) thời gian. Vòng lặp {2} thực hiện (n-i) lần, mỗi lần O(1) do đó vòng lặp {2} tốn O((n-i).1) = O(n-i).Vòng lặp {1} lặp có i chạy từ 1 đến n-1 nên thời gian thực hiện của vòng lặp {1} và cũng là độ phức tạp của giải thuật là:
$T(n) = sum_{i=1}^{n-1}(n-i) = frac{n.(n-1)}{2} = O(n^2)$
Chú ý: Trong trường hợp vòng lặp không xác định được số lần lặp thì chúng ta phải lấy số lần lặp trong trường hợp xấu nhất.
Tìm kiếm tuần tự. Hàm tìm kiếm Search nhận vào một mảng a có n số nguyên và một số nguyên x, hàm sẽ trả về giá trị logic TRUE nếu tồn tại một phần tử a[i] = x, ngược lại hàm trả về FALSE.
Giải thuật tìm kiếm tuần tự là lần lượt so sánh x với các phần tử của mảng a, bắt đầu từ a[1], nếu tồn tại a[i] = x thì dừng và trả về TRUE, ngược lại nếu tất cả các phần tử của a đều khác X thì trả về FALSE.

FUNCTION Search(a:ARRAY[1..n] OF Integer;x:Integer):Boolean;
VAR i:Integer;
	Found:Boolean;
BEGIN
	i:=1; 											{1}
	Found:=FALSE; 									{2}
	WHILE(i<=n) AND (not Found) DO					{3}
		IF A[i]=X THEN Found:=TRUE ELSE i:=i+1; 	{4}
	Search:=Found; 									{5}
END;

Ta thấy các lệnh {1}, {2}, {3} và {5} nối tiếp nhau, do đó độ phức tạp của hàm Search chính là độ phức tạp lớn nhất trong 4 lệnh này. Dễ dàng thấy rằng ba lệnh {1}, {2} và {5} đều có độ phức tạp O(1) do đó độ phức tạp của hàm Search chính là độ phức tạp của lệnh {3}. Lồng trong lệnh {3} là lệnh {4}. Lệnh {4} có độ phức tạp O(1). Trong trường hợp xấu nhất (tất cả các phần tử của mảng a đều khác x) thì vòng lặp {3} thực hiện n lần, vậy ta có T(n) = O(n).
Ðộ phức tạp của chương trình có gọi chương trình con không đệ quy
Nếu chúng ta có một chương trình với các chương trình con không đệ quy, để tính thời gian thực hiện của chương trình, trước hết chúng ta tính thời gian thực hiện của các chương trình con không gọi các chương trình con khác. Sau đó chúng ta tính thời gian thực hiện của các chương trình con chỉ gọi các chương trình con mà thời gian thực hiện của chúng đã được tính. Chúng ta tiếp tục quá trình đánh giá thời gian thực hiện của mỗi chương trình con sau khi thời gian thực hiện của tất cả các chương trình con mà nó gọi đã được đánh giá. Cuối cùng ta tính thời gian cho chương trình chính.
Giả sử ta có một hệ thống các chương trình gọi nhau theo sơ đồ sau:
dequy
Chương trình A gọi hai chương trình con là B và C, chương trình B gọi hai chương trình con là B1 và B2, chương trình B1 gọi hai chương trình con là B11 và B12.
Ðể tính thời gian thực hiện của A, ta tính theo các bước sau:
1. Tính thời gian thực hiện của C, B2, B11 và B12. Vì các chương trình con này không gọi chương trình con nào cả.
2. Tính thời gian thực hiện của B1. Vì B1 gọi B11 và B12 mà thời gian thực hiện của B11 và B12 đã được tính ở bước 1.
3. Tính thời gian thực hiện của B. Vì B gọi B1 và B2 mà thời gian thực hiện của B1 đã được tính ở bước 2 và thời gian thực hiện của B2 đã được tính ở bước 1.
4. Tính thời gian thực hiện của A. Vì A gọi B và C mà thời gian thực hiện của B đã được tính ở bước 3 và thời gian thực hiện của C đã được tính ở bước 1.
Ta có thể viết lại chương trình sắp xếp bubble như sau: Trước hết chúng ta viết thủ tục Swap để thực hiện việc hoàn đổi hai phần tử cho nhau, sau đó trong thủ tục Bubble, khi cần ta sẽ gọi đến thủ tục Swap này.

procedure Swap (var x, y: integer);
var temp: integer;
begin
	temp := x;
	x := y;
	y := temp;
end;
procedure Bubble (var a: array[1..n] of integer);
var i,j :integer;
begin
	for i:=1 to n-1 do								{1}
		for j:=n downto i+1 do						{2}
			if a[j-1]>a[j] then
				Swap(a[j-1], a[j]);					{3}
end;

Trong cách viết trên, chương trình Bubble gọi chương trình con Swap, do đó để tính thời gian thực hiện của Bubble, trước hết ta cần tính thời gian thực hiện của Swap. Dễ thấy thời gian thực hiện của Swap là O(1) vì nó chỉ bao gồm 3 lệnh gán. Trong Bubble, lệnh {3} gọi Swap nên chỉ tốn O(1), lệnh {2} thực hiện n-i lần, mỗi lần tốn O(1) nên tốn O(n-i). Lệnh {1} thực hiện n-1 lần nên:
$T(n) = sum_{i=1}^{n-1}(n-i) = frac{n.(n-1)}{2} = O(n^2)$
Phân tích các chương trình Ðệ quy
Với các chương trình có gọi các chương trình con đệ quy, ta không thể áp dụng cách tính như vừa trình bày bởi vì một chương trình đệ quy sẽ gọi chính bản thân nó và nếu theo phương pháp đó thì, để tính thời gian thực hiên của chương trình A, ta phải tính thời gian thực hiện của chương trình A và cái vòng luẩn quẩn ấy không thể kết thúc được.
Với các chương trình đệ quy, trước hết ta cần thành lập các phương trình đệ quy, sau đó giải phương trình đệ quy, nghiệm của phương trình đệ quy sẽ là thời gian thực hiện của chương trình đệ quy.
Thành lập phương trình đệ quy
Phương trình đệ quy là một phương trình biểu diễn mối liên hệ giữa T(n) và T(k), trong đó T(n) là thời gian thực hiện chương trình với kích thước dữ liệu nhập là n, T(k) thời gian thực hiện chương trình với kích thước dữ liệu nhập là k, với k < n. Ðể thành lập được phương trình đệ quy, ta phải căn cứ vào chương trình đệ quy. Thông thường một chương trình đệ quy để giải bài toán kích thước n, phải có ít nhất một trường hợp dừng ứng với một n cụ thể và lời gọi đệ quy để giải bài toán kích thước k (k0 chương trình phải gọi đệ quy Giai_thua(n-1), việc gọi đệ quy này tốn T(n-1), sau khi có kết quả của việc gọi đệ quy, chương trình phải nhân kết quả đó với n và gán cho Giai_thua. Thời gian để thực hiện phép nhân và phép gán là một hằng C2. Vậy ta có
$T(n) = egin{cases} C1 & n=0 \ F(T(n-1)) + C2 & n>0 end{cases}$
Ðây là phương trình đệ quy để tính thời gian thực hiện của chương trình đệ quy Giai_thua.
Chúng ta xét thủ tục MergeSort một cách phác thảo như sau:

FUNCTION MergeSort (L:List; n:Integer):List;
VAR L1,L2:List;
BEGIN
	IF n=1 THEN RETURN(L)
	ELSE
	BEGIN
		Chia đôi L thành L1 và L2, với độ dài n/2;
		RETURN(Merge(MergeSort(L1,n/2),MergeSort(L2,n/2)));
	END;
END;

Chẳng hạn để sắp xếp danh sách L gồm 8 phần tử 7, 4, 8, 9, 3, 1, 6, 2 ta có mô hình minh họa của MergeSort như sau:

Hàm MergeSort nhận một danh sách có độ dài n và trả về một danh sách đã được sắp xếp. Thủ tục Merge nhận hai danh sách đã được sắp L1 và L2 mỗi danh sách có độ dài n/2 trộn chúng lại với nhau để được một danh sách gồm n phần tử có thứ tự. Giải thuật chi tiết của Merge ta sẽ bàn sau, chúng ta chỉ để ý rằng thời gian để Merge các danh sách có độ dài n/2 là O(n). Gọi T(n) là thời gian thực hiện MergeSort một danh sách n phần tử thì T(n/2) là thời gian thực hiện MergeSort một danh sách n/2 phần tử. Khi L có độ dài 1 (n = 1) thì chương trình chỉ làm một việc duy nhất là return(L), việc này tốn O(1) = C1 thời gian. Trong trường hợp n > 1, chương trình phải thực hiện gọi đệ quy MerSort hai lần cho L1 và L2 với độ dài n/2 do đó thời gian để gọi hai lần đệ quy này là 2T(n/2). Ngoài ra còn phải tốn thời gian cho việc chia danh sách L thành hai nửa bằng nhau và trộn hai danh sách kết quả (Merge). Người ta xác đinh được thời gian để chia danh sách và Merge là O(n) = C2n. Vậy ta có phương trình đệ quy như sau:
$T(n) = egin{cases} C1 & n=1 \ 2T(frac{n}{2}) + C2.n & n>1 end{cases}$

V. GIẢI PHƯƠNG TRÌNH ĐỆ QUY

Phuơng pháp truy hồi:
Dùng đệ quy để thay thế bất kỳ T(m) với m<n vào vế phải của PT cho đến khi m=1.
VD: Giải phương trình đệ quy:
$T(n) = egin{cases} C1 & n=1 \ 2T(frac{n}{2}) + C2.n & n>1 end{cases}$

Ta có:
$T(n) = 2T(frac{n}{2}) + C2.n$
$=2[2T(frac{n}{2})+ C2.frac{n}{2}] + C2.n = 4T(frac{n}{4}) + 2.C2.n$
$=4[2T(frac{n}{8})+ C2.frac{n}{4}] + C2.n = 8T(frac{n}{8}) + 3.C2.n$
= …
$=2^{i}.T(frac{n}{2^{i}}) + i.C2.n$
Giải sử n=2^k và khi kết thúc ta có i = k.
$Rightarrow T(n) = 2^{k}T(1) + kC2n$
Lại có:
$n=2^k Rightarrow k = logn, T(1) = C1\ Rightarrow T(n) = 2^{k}T(1) + kC2n\ Rightarrow T(n) = n.C1 + C2.n.logn\ Rightarrow T(n) = O(n.logn)$

Phương pháp tổng quát
Chia bài toán thành a bài toán con và mỗi bài toán có kích thước n/b. Và cứ chia như vậy đến khi bài toán đủ nhỏ để giải quyết (đệ quy). Và sau khi dùng phương pháp này người ta đã chỉ ra rằng đối với phương trình đệ quy:
$T(n) = egin{cases} C1 & n=1 \ aT(frac{n}{b}) + C2.n & n>1 end{cases}$
Ta có:
T(n) = C1 nếu n=1
Với n>1 ta có:
$latex T(n) = egin{cases} O(n) & ext{ if } a b end{cases}$

Bài viết có tham khảo ở Giáo trình phân tích giải thuật – ĐH Cần Thơ

Bình luận về bài viết này

Trịnh Tiến Mạnh

27 chủ đề

6824 bài viết

[Thuật toán]Cách tính độ phức tạp thuật toán – Algorithm complexity