- Bất biến của Min Stack \(O(1)\): Giá trị nhỏ nhất của toàn bộ ngăn xếp tại thời điểm có \(k\) phần tử chỉ phụ thuộc vào \(k\) phần tử đang nằm bên dưới. Bằng cách gắn kèm giá trị nhỏ nhất tích lũy
(val, cur_min)vào mỗi nút của ngăn xếp, khi đỉnh ngăn xếp bịpop(), giá trị nhỏ nhất của \(k - 1\) phần tử còn lại lập tức lộ ra ở đỉnh mới mà không cần quét lại. - Đảo chiều LIFO thành FIFO bằng hai ngăn xếp: Một lần đổ dữ liệu từ ngăn xếp này sang ngăn xếp kia sẽ đảo ngược thứ tự các phần tử. Do đó, đẩy phần tử vào ngăn xếp đầu vào (
in_st) rồi đổ sang ngăn xếp đầu ra (out_st) sẽ đưa phần tử vào sớm nhất lên đúng đỉnh củaout_st. - Nguyên tắc đổ lười (Lazy Transfer): Chỉ chuyển phần tử từ
in_stsangout_stkhi và chỉ khiout_sthoàn toàn rỗng. Nếu đổ ngay mỗi lầnpushhoặc đổ khiout_stcòn phần tử, thứ tự FIFO sẽ bị phá vỡ hoặc độ phức tạp bị đẩy lên \(O(n)\) cho mỗi thao tác. - Độ phức tạp khấu hao (Amortized \(O(1)\)): Mỗi phần tử trong suốt vòng đời của nó chỉ được đẩy vào
in_stđúng \(1\) lần, lấy khỏiin_stđúng \(1\) lần, đẩy vàoout_stđúng \(1\) lần và lấy khỏiout_stđúng \(1\) lần. Tổng số phép toán trên \(n\) phần tử là \(4n\), suy ra chi phí trung bình mỗi thao tác là \(O(1)\).
Phần 1: Thiết kế Min Stack truy vấn giá trị nhỏ nhất trong O(1)
Tại sao một biến min_val đơn lẻ không đủ?
Khi mới nghe yêu cầu thiết kế cấu trúc ngăn xếp hỗ trợ bốn thao tác push(x), pop(), top() và getMin() đều trong thời gian \(O(1)\), phản xạ đầu tiên của nhiều người là dùng một ngăn xếp thông thường kèm theo một biến số nguyên min_val cập nhật mỗi khi có phần tử mới nhỏ hơn được đẩy vào.
Cách này hoạt động đúng khi chỉ có thao tác push(x), nhưng sụp đổ ngay khi gọi pop(): giả sử ta lần lượt đẩy 5, 2, 1 vào ngăn xếp. Lúc này min_val = 1. Khi gọi pop() để lấy 1 ra khỏi đỉnh, giá trị nhỏ nhất mới của ngăn xếp phải quay về 2. Nhưng nếu chỉ có một biến min_val, ta không biết giá trị nhỏ nhất trước khi 1 xuất hiện là bao nhiêu nếu không duyệt lại toàn bộ ngăn xếp mất \(O(n)\) thời gian.
Lưu trạng thái nhỏ nhất theo từng tầng ngăn xếp
Điểm đặc biệt của ngăn xếp là các phần tử chỉ được thêm vào và lấy ra ở cùng một đầu (đỉnh ngăn xếp). Điều này kéo theo một tính chất quan trọng: chừng nào phần tử ở tầng thứ \(i\) vẫn còn nằm trong ngăn xếp, thì tập hợp các phần tử từ đáy ngăn xếp (tầng \(1\)) đến tầng \(i\) là hoàn toàn bất biến — không có phần tử nào ở bên dưới nó có thể bị xóa trước nó.
Vì vậy, giá trị nhỏ nhất của tập hợp các phần tử từ đáy đến tầng \(i\), ký hiệu là \(m_i\), là một hằng số cố định ngay từ lúc phần tử thứ \(i\) được đẩy vào:
\[m_i = \begin{cases} x_1 & \text{nếu } i = 1 \\ \min(m_{i-1}, x_i) & \text{nếu } i \gt 1 \end{cases}\]
Từ công thức truy hồi này, ta có hai cách cài đặt chuẩn trong phỏng vấn:
- Cách 1 — Ngăn xếp lưu cặp
(val, cur_min): Mỗi phần tử trên ngăn xếp là một bộ đôi gồm giá trị thựcvalvà giá trị nhỏ nhất tính từ đáy tới chính nócur_min. Khipop(), cặp ở đỉnh bị gỡ bỏ và đỉnh mới bên dưới đã lưu sẵn giá trị nhỏ nhất của phần còn lại. - Cách 2 — Ngăn xếp phụ
min_sttiết kiệm bộ nhớ: Tách riêng ngăn xếp chínhst(lưuval) và ngăn xếp phụmin_st. Ta chỉ đẩyxvàomin_stkhimin_stđang rỗng hoặc khi \(x \le \text{min\_st.top()}\) (chú ý dấu \(\le\) bắt buộc phải có dấu bằng để xử lý trường hợp có nhiều phần tử trùng giá trị nhỏ nhất). Khist.pop()lấy ra giá trị bằng đúngmin_st.top(), ta đồng thời gọimin_st.pop().
(val, cur_min) giúp khôi phục ngay giá trị nhỏ nhất sau mỗi lệnh pop) và Hàng đợi bằng 2 ngăn xếp (bên phải, đảo thứ tự LIFO thành FIFO nhờ bước đổ từ in_st sang out_st khi out_st rỗng).Phần 2: Cài đặt Hàng đợi (FIFO) bằng hai Ngăn xếp (LIFO)
Cơ chế đảo ngược kép bằng hai ngăn xếp in_st và out_st
Hàng đợi (Queue) yêu cầu phần tử nào vào trước phải được lấy ra trước (push vào cuối hàng, pop và peek ở đầu hàng). Trong khi đó, ngăn xếp chỉ cho phép chạm tới phần tử mới nhất ở đỉnh.
Để biến đổi LIFO thành FIFO, ta sử dụng hai ngăn xếp độc lập:
- Ngăn xếp đầu vào
in_st: Chuyên nhận các phần tử mới từ thao tácpush(x). Mỗi lệnhpush(x)chỉ đơn giản gọiin_st.push(x)trong thời gian \(O(1)\) chặt chẽ. Ở trongin_st, phần tử mới nhất nằm ở đỉnh, còn phần tử cũ nhất bị chôn ở đáy. - Ngăn xếp đầu ra
out_st: Chuyên phục vụ hai thao tác lấy/xem phần tử đầu hàng làpop()vàpeek(). Khi cần lấy phần tử ở đầu hàng đợi:- Nếu
out_stđang còn phần tử, đỉnh củaout_stchính là phần tử vào sớm nhất hiện tại — ta đọc hoặc lấy ngay từout_st.top()trong \(O(1)\). - Nếu
out_stđang rỗng, ta rút lần lượt toàn bộ phần tử từ đỉnh củain_stvà đẩy sangout_stcho tới khiin_stcạn sạch. Nhờ việc lấy từ đỉnhin_strồi đẩy xuốngout_st, thứ tự các phần tử bị lật ngược hoàn toàn: phần tử từng nằm ở đáyin_st(vào sớm nhất) nay vươn lên nằm ở đỉnhout_st!
- Nếu
Chứng minh độ phức tạp khấu hao (Amortized \(O(1)\))
Nhiều ứng viên lo ngại rằng vòng lặp while (!in_st.empty()) trong hàm chuyển dữ liệu có thể chạy \(n\) bước, vậy tại sao bài toán vẫn được công nhận là \(O(1)\)? Câu trả lời nằm ở phân tích khấu hao (Amortized Analysis) theo phương pháp kế toán (Accounting Method):
Xét một chuỗi bất kỳ gồm \(m\) thao tác (push, pop, peek, empty) bắt đầu từ hàng đợi rỗng. Hãy theo dõi hành trình của một phần tử \(x\) cụ thể kể từ lúc nó được đưa vào hàng đợi cho tới lúc nó rời khỏi hàng đợi vĩnh viễn:
- Lệnh
in_st.push(x): thực hiện đúng \(1\) lần khi gọipush(x). - Lệnh
in_st.pop(): thực hiện tối đa \(1\) lần khiout_strỗng và cần đổ dữ liệu. - Lệnh
out_st.push(x): thực hiện tối đa \(1\) lần ngay trong lần đổ dữ liệu đó. - Lệnh
out_st.pop(): thực hiện tối đa \(1\) lần khi \(x\) rời khỏi hàng đợi.
Như vậy, mỗi phần tử chỉ chịu tối đa \(4\) phép toán ngăn xếp cơ sở trong suốt cuộc đời của nó, bất kể có bao nhiêu lệnh peek hay pop xen kẽ. Tổng chi phí cho \(m\) thao tác không bao giờ vượt quá \(4m\) phép toán cơ sở, suy ra chi phí trung bình trên mỗi thao tác là \(O(1)\) khấu hao, dù một thao tác pop()/ peek() riêng lẻ tại thời điểm đổ hàng có chi phí trường hợp xấu nhất là \(O(n)\).
| Thao tác | Min Stack (Lưu cặp (val, cur_min)) |
Hàng đợi bằng 2 Stack (Trường hợp xấu nhất) | Hàng đợi bằng 2 Stack (Trung bình khấu hao) |
|---|---|---|---|
Thêm phần tử (push) |
\(O(1)\) chặt chẽ | \(O(1)\) chặt chẽ (in_st.push) |
\(O(1)\) |
Lấy phần tử (pop) |
\(O(1)\) chặt chẽ | \(O(n)\) (chỉ khi out_st rỗng phải đổ từ in_st) |
\(O(1)\) khấu hao |
Xem phần tử (top / peek) |
\(O(1)\) chặt chẽ | \(O(n)\) (chỉ khi out_st rỗng phải đổ từ in_st) |
\(O(1)\) khấu hao |
Truy vấn phụ (getMin / empty) |
\(O(1)\) chặt chẽ | \(O(1)\) chặt chẽ | \(O(1)\) |
Ví dụ chạy tay từng bước cho cả hai cấu trúc
Bảng chạy tay 1: Min Stack với chuỗi thao tác push(5), push(2), push(4), push(1), getMin(), pop(), getMin()
| Bước | Lệnh gọi | Trạng thái ngăn xếp (từ đáy lên đỉnh: (val, cur_min)) |
Kết quả trả về | Giải thích |
|---|---|---|---|---|
| 1 | push(5) |
[(5, 5)] |
— | Ngăn xếp rỗng nên cur_min = 5. |
| 2 | push(2) |
[(5, 5), (2, 2)] |
— | \(\min(5, 2) = 2\), lưu cặp (2, 2) ở đỉnh. |
| 3 | push(4) |
[(5, 5), (2, 2), (4, 2)] |
— | \(\min(2, 4) = 2\), đỉnh mới mang val = 4 nhưng giữ cur_min = 2. |
| 4 | push(1) |
[(5, 5), (2, 2), (4, 2), (1, 1)] |
— | \(\min(2, 1) = 1\), cập nhật cur_min = 1 tại đỉnh. |
| 5 | getMin() |
[(5, 5), (2, 2), (4, 2), (1, 1)] |
1 |
Đọc trực tiếp trường cur_min của cặp ở đỉnh (1, 1). |
| 6 | pop() |
[(5, 5), (2, 2), (4, 2)] |
— | Gỡ cặp (1, 1) khỏi đỉnh; cặp (4, 2) trở thành đỉnh mới. |
| 7 | getMin() |
[(5, 5), (2, 2), (4, 2)] |
2 |
Đọc trường cur_min của đỉnh (4, 2) thu được ngay 2 trong \(O(1)\). |
Bảng chạy tay 2: Hàng đợi bằng 2 Stack với chuỗi push(10), push(20), peek(), push(30), pop(), peek()
| Bước | Lệnh gọi | in_st (đáy \(\to\) đỉnh) |
out_st (đáy \(\to\) đỉnh) |
Kết quả | Giải thích |
|---|---|---|---|---|---|
| 1 | push(10) |
[10] |
[] |
— | Đẩy thẳng 10 vào in_st. |
| 2 | push(20) |
[10, 20] |
[] |
— | Đẩy thẳng 20 vào in_st. |
| 3 | peek() |
[] |
[20, 10] |
10 |
Do out_st đang rỗng, đổ lần lượt 20 rồi 10 từ in_st sang out_st. Đỉnh out_st là 10. |
| 4 | push(30) |
[30] |
[20, 10] |
— | Đẩy 30 vào in_st; out_st giữ nguyên không đụng tới. |
| 5 | pop() |
[30] |
[20] |
10 |
Vì out_st không rỗng, lấy ngay đỉnh 10 của out_st mà không đổ 30 sang. |
| 6 | peek() |
[30] |
[20] |
20 |
Đỉnh hiện tại của out_st là 20 (phần tử vào thứ hai sau 10). |
Cài đặt hoàn chỉnh bằng C++17, Python và Java 21
Đoạn mã dưới đây cài đặt cả hai lớp MinStack và MyQueue trong cùng một chương trình. Chương trình nhận danh sách các lệnh kiểm thử cho MinStack hoặc MyQueue từ luồng nhập chuẩn và in ra dãy kết quả tương ứng.
#include <algorithm>
#include <iostream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
class MinStack {
stack<pair<long long, long long>> st; // {val, current_min}
public:
void push(long long x) {
long long cur_min = st.empty() ? x : min(x, st.top().second);
st.push({x, cur_min});
}
void pop() { st.pop(); }
long long top() const { return st.top().first; }
long long getMin() const { return st.top().second; }
};
class MyQueue {
stack<long long> in_st, out_st;
void transfer() {
if (out_st.empty()) {
while (!in_st.empty()) {
out_st.push(in_st.top());
in_st.pop();
}
}
}
public:
void push(long long x) { in_st.push(x); }
long long pop() {
transfer();
long long v = out_st.top();
out_st.pop();
return v;
}
long long peek() {
transfer();
return out_st.top();
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q;
if (!(cin >> q)) {
MinStack ms;
ms.push(-2);
ms.push(0);
ms.push(-3);
long long a = ms.getMin();
ms.pop();
long long b = ms.top();
long long c = ms.getMin();
cout << a << " " << b << " " << c << "\n";
return 0;
}
MinStack ms;
MyQueue mq;
vector<long long> outs;
for (int i = 0; i < q; i++) {
string op;
cin >> op;
if (op == "MPUSH") {
long long x; cin >> x; ms.push(x);
} else if (op == "MPOP") {
ms.pop();
} else if (op == "MTOP") {
outs.push_back(ms.top());
} else if (op == "MMIN") {
outs.push_back(ms.getMin());
} else if (op == "QPUSH") {
long long x; cin >> x; mq.push(x);
} else if (op == "QPOP") {
outs.push_back(mq.pop());
} else if (op == "QPEEK") {
outs.push_back(mq.peek());
}
}
for (size_t i = 0; i < outs.size(); i++) {
if (i) cout << " ";
cout << outs[i];
}
cout << "\n";
return 0;
}
import sys
class MinStack:
def __init__(self):
self.st = []
def push(self, x: int) -> None:
cur_min = x if not self.st else min(x, self.st[-1][1])
self.st.append((x, cur_min))
def pop(self) -> None:
self.st.pop()
def top(self) -> int:
return self.st[-1][0]
def get_min(self) -> int:
return self.st[-1][1]
class MyQueue:
def __init__(self):
self.in_st = []
self.out_st = []
def _transfer(self) -> None:
if not self.out_st:
while self.in_st:
self.out_st.append(self.in_st.pop())
def push(self, x: int) -> None:
self.in_st.append(x)
def pop(self) -> int:
self._transfer()
return self.out_st.pop()
def peek(self) -> int:
self._transfer()
return self.out_st[-1]
def main():
tokens = sys.stdin.read().split()
if not tokens:
ms = MinStack()
ms.push(-2)
ms.push(0)
ms.push(-3)
a = ms.get_min()
ms.pop()
print(f"{a} {ms.top()} {ms.get_min()}")
return
q = int(tokens[0])
idx = 1
ms = MinStack()
mq = MyQueue()
outs = []
for _ in range(q):
op = tokens[idx]
if op == "MPUSH":
ms.push(int(tokens[idx + 1]))
idx += 2
elif op == "MPOP":
ms.pop()
idx += 1
elif op == "MTOP":
outs.append(str(ms.top()))
idx += 1
elif op == "MMIN":
outs.append(str(ms.get_min()))
idx += 1
elif op == "QPUSH":
mq.push(int(tokens[idx + 1]))
idx += 2
elif op == "QPOP":
outs.append(str(mq.pop()))
idx += 1
elif op == "QPEEK":
outs.append(str(mq.peek()))
idx += 1
print(" ".join(outs))
if __name__ == "__main__":
main()
import java.util.*;
public class Main {
static class MinStack {
private final Deque<long[]> st = new ArrayDeque<>();
public void push(long x) {
long curMin = st.isEmpty() ? x : Math.min(x, st.peek()[1]);
st.push(new long[]{x, curMin});
}
public void pop() { st.pop(); }
public long top() { return st.peek()[0]; }
public long getMin() { return st.peek()[1]; }
}
static class MyQueue {
private final Deque<Long> inSt = new ArrayDeque<>();
private final Deque<Long> outSt = new ArrayDeque<>();
private void transfer() {
if (outSt.isEmpty()) {
while (!inSt.isEmpty()) {
outSt.push(inSt.pop());
}
}
}
public void push(long x) { inSt.push(x); }
public long pop() {
transfer();
return outSt.pop();
}
public long peek() {
transfer();
return outSt.peek();
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
if (!sc.hasNextInt()) {
MinStack ms = new MinStack();
ms.push(-2);
ms.push(0);
ms.push(-3);
long a = ms.getMin();
ms.pop();
System.out.println(a + " " + ms.top() + " " + ms.getMin());
return;
}
int q = sc.nextInt();
MinStack ms = new MinStack();
MyQueue mq = new MyQueue();
List<String> outs = new ArrayList<>();
for (int i = 0; i < q; i++) {
String op = sc.next();
switch (op) {
case "MPUSH" -> ms.push(sc.nextLong());
case "MPOP" -> ms.pop();
case "MTOP" -> outs.add(String.valueOf(ms.top()));
case "MMIN" -> outs.add(String.valueOf(ms.getMin()));
case "QPUSH" -> mq.push(sc.nextLong());
case "QPOP" -> outs.add(String.valueOf(mq.pop()));
case "QPEEK" -> outs.add(String.valueOf(mq.peek()));
}
}
System.out.println(String.join(" ", outs));
}
}
Các lỗi kinh điển trong phỏng vấn và cách tự kiểm chứng
- Đổ dữ liệu từ
in_stsangout_stkhiout_stchưa rỗng: Ở Bước 4 và Bước 5 của bảng chạy tay thứ hai, nếu ngay khipush(30)hoặc trước khipop()mà bạn vẫn đổ30từin_stsangout_st(trong lúcout_stđang chứa[20, 10]), thì30sẽ đè lên đỉnh củaout_stvà bị lấy ra trước cả10lẫn20! Điều kiện tiên quyếtif (out_st.empty())trong hàmtransfer()là bất biến sống còn của thuật toán. - Dùng dấu \(\lt\) thay vì \(\le\) khi cài đặt Min Stack bằng hai ngăn xếp rời: Nếu bạn tách riêng ngăn xếp chính
stvà ngăn xếp phụmin_st, giả sử chuỗi đẩy vào làpush(2), push(1), push(1). Nếu chỉ đẩy vàomin_stkhi \(x \lt \text{min\_st.top()}\), số1thứ hai sẽ bị bỏ qua. Đến khi gọipop()một lần để lấy số1thứ hai ra, bạn thấyst.top() == min_st.top() == 1nên xóa luôn số1duy nhất trongmin_st, làm giá trị nhỏ nhất nhảy sai về2dù trongstvẫn còn một số1. Lưu trực tiếp cặp(val, cur_min)như trong code mẫu giúp tránh hoàn toàn bẫy này. - Mẹo tối ưu hóa \(O(1)\) bộ nhớ phụ bằng kỹ thuật lưu hiệu số (khi phỏng vấn nâng cao): Nếu người phỏng vấn cấm dùng thêm bộ nhớ \(O(n)\) cho
cur_min, ta có thể lưu hiệu số \(d = x - \text{min\_val}\) vào ngăn xếp (cần dùng kiểu số nguyên 64-bitlong longđể tránh tràn số khi trừ số âm cho số dương). Nếu \(d \lt 0\), điều đó báo hiệu phần tử vừa đẩy vào nhỏ hơnmin_valcũ, ta cập nhậtmin_val = x; khipop()gặp đỉnh âm \(d \lt 0\), ta khôi phụcmin_valcũ bằng công thức \(\text{min\_val\_cũ} = \text{min\_val\_hiện\_tại} - d\). - Cách tự kiểm chứng tại nhà: Để tự kiểm tra lớp
MinStackvàMyQueue, bạn có thể đối chiếu đầu ra của chúng với một mảng động chuẩn (std::vectorkết hợp*std::min_elementcho Min Stack, vàstd::dequechuẩn cho Queue) trên chuỗi thao tác ngẫu nhiên gồm các giá trị trùng nhau (ví dụ miền giá trị chỉ gồm \(\{-1, 0, 1\}\)) và xen kẽ liên tục các đợtpush-popđến khi cấu trúc rỗng hoàn toàn rồi lạipushtiếp.
Luyện ngay trên Big-O Coding
Sau khi nắm vững bất biến trạng thái của ngăn xếp lưu cực trị và cơ chế đảo chiều bằng hai ngăn xếp, bạn hãy luyện tập ngay bài toán Min Stack cùng các bài toán biến đổi biểu thức trên ngăn xếp trong lộ trình Coding Interview 150:
Có thể kết hợp cả hai ý tưởng trên để thiết kế Hàng đợi lấy giá trị nhỏ nhất (Min Queue) trong \(O(1)\) khấu hao không?
Hoàn toàn được, và đây chính là câu hỏi mở rộng rất hay gặp ở cuối buổi phỏng vấn! Khi cài đặt hàng đợi bằng hai ngăn xếp in_st và out_st, nếu ta nâng cấp cả in_st lẫn out_st thành hai Min Stack (mỗi phần tử trong cả hai ngăn xếp đều lưu cặp (val, cur_min) của riêng ngăn xếp đó), thì giá trị nhỏ nhất của toàn bộ hàng đợi tại mọi thời điểm chính là \(\min(\text{in\_st.getMin()}, \text{out\_st.getMin()})\). Mọi thao tác thêm vào cuối hàng, lấy ra ở đầu hàng và truy vấn cực tiểu của cửa sổ đều đạt \(O(1)\) khấu hao.
Ngược lại, làm sao cài đặt một Ngăn xếp (LIFO) chỉ bằng Hàng đợi (FIFO)?
Khác với việc dùng hai ngăn xếp tạo ra hàng đợi đạt \(O(1)\) khấu hao nhờ tính chất đảo chiều của ngăn xếp, thao tác đổ dữ liệu giữa hai hàng đợi FIFO không làm đảo ngược thứ tự phần tử (phần tử đầu hàng đợi 1 đổ sang hàng đợi 2 vẫn đứng đầu hàng đợi 2). Vì vậy, để cài đặt Ngăn xếp bằng Hàng đợi (LeetCode 225), ta chỉ cần dùng một hàng đợi duy nhất q: mỗi khi đẩy phần tử mới x vào cuối hàng (q.push(x)), ta lặp \(|q| - 1\) lần thao tác rút phần tử đầu hàng đưa xuống cuối hàng (q.push(q.front()); q.pop()). Khi đó x vươn lên đứng đầu hàng đợi, giúp pop() và top() chạy trong \(O(1)\), còn push(x) tốn \(O(n)\).
Trong hệ thống thời gian thực (Real-time System), hàng đợi bằng hai ngăn xếp có nhược điểm gì?
Mặc dù chi phí trung bình khấu hao của hàng đợi hai ngăn xếp là \(O(1)\), độ trễ đuôi (tail latency / p99 latency) của một lệnh pop() đơn lẻ khi out_st vừa cạn có thể vọt lên \(O(n)\) do phải chép dồn toàn bộ \(n\) phần tử từ in_st sang out_st. Trong các hệ thống thời gian thực yêu cầu độ trễ mỗi lệnh bị chặn trên nghiêm ngặt (worst-case \(O(1)\)), người ta dùng danh sách liên kết hoặc bộ đệm vòng (circular buffer) thay vì hai ngăn xếp.
Luyện LeetCode thực chiến theo pattern, giải bài trong 45 phút và mock interview cùng AI. 16 buổi online, lớp 7–12 học viên, chọn C++, Java hoặc Python.


