Phỏng vấn

Cách ôn lại bài LeetCode không bị quên: Phương pháp Spaced Repetition và Sổ tay Khuôn mẫu

Cảm giác thất vọng nhất của người luyện phỏng vấn thuật toán là khi gặp lại đúng một bài LeetCode mình đã từng giải xanh (Accepted) cách đây 3 tuần nhưng nhìn vào màn hình lại hoàn toàn trống rỗng. Hiện tượng này không phải do bạn kém thông minh, mà do bạn đang nạp kiến thức vào trí nhớ ngắn hạn thay vì mã hóa thành khuôn mẫu dài hạn.

Ý chính
  • Theo Đường cong Quên lãng Ebbinghaus, trí nhớ về kiến thức mới học giảm đi khoảng một nửa chỉ sau vài ngày đến vài tuần nếu không được ôn lại; việc cày một mạch 300 bài không ôn lại kém hiệu quả hơn nhiều so với làm 120 bài có chu kỳ lặp lại.
  • Tuyệt đối không học thuộc lòng từng dòng code; thứ duy nhất cần ghi nhớ là Chuỗi suy diễn 3 bước: Tín hiệu nhận diện đề bài (Trigger) \(\rightarrow\) Bất biến của cấu trúc dữ liệu (Invariant) \(\rightarrow\) Bẫy biên từng mắc phải (Pitfall).
  • Áp dụng thuật toán Lặp lại Ngắt quãng (Spaced Repetition — SM-2) với các mốc giãn cách \(1 \rightarrow 6 \rightarrow 15 \rightarrow 38\text{ ngày}\) (khi lần nào cũng tự chấm \(q = 4\)) dựa trên điểm tự đánh giá độ trôi chảy sau mỗi lần giải.
  • Khi ôn lại một bài cũ mà không đủ thời gian gõ toàn bộ code, hãy dùng kỹ thuật Phác thảo khung 5 phút (5-Minute Outline): viết công thức chuyển trạng thái hoặc bất biến + độ phức tạp ra giấy nháp rồi đối chiếu với sổ tay.

Giải mã nghịch lý: Vì sao giải 300 bài LeetCode vẫn quên sạch sau 1 tháng?

Khi thực hành theo lộ trình luyện LeetCode phỏng vấn Big Tech, đa số người học mắc phải một trong hai sai lầm nhận thức sau:

  1. Ảo tưởng năng lực từ việc đọc lời giải (Illusion of Competence): Bạn suy nghĩ 15 phút chưa ra, sau đó mở tab Editorial / Solutions đọc lời giải mẫu. Khi đọc từng dòng giải thích của tác giả, bạn gật gù thấy rất hợp lý rồi quay lại gõ code theo trí nhớ vừa đọc và bấm Submit báo xanh. Lúc đó, bạn đang dùng Trí nhớ Nhận diện (Recognition) chứ chưa hề tự mình thực hiện Truy hồi Chủ động (Active Recall). Chỉ 48 giờ sau, bạn đã quên gần hết đoạn code đó vì chưa từng tự truy hồi lần nào.
  2. Nhớ "Triệu chứng" thay vì nhớ "Nguyên lý": Bạn cố nhớ rằng "Bài Trapping Rain Water thì tạo 2 biến left_max và right_max" nhưng không hiểu tại sao con trỏ bên thấp hơn lại được phép chốt lượng nước ngay lập tức. Khi người phỏng vấn đổi nhẹ đề bài thành tính diện tích hình chữ nhật lớn nhất hoặc đổi sang ma trận 2 chiều, trí nhớ máy móc lập tức sụp đổ.

Để khắc phục tận gốc, bạn cần chuyển từ chế độ "Sưu tầm số bài đã giải" sang chế độ "Nuôi dưỡng Khuôn mẫu bằng Lặp lại Ngắt quãng".

Phương pháp Sổ tay Khuôn mẫu 3 dòng (3-Line Pattern Log)

Ngay sau khi giải xong một bài toán (dù tự giải hay phải xem gợi ý), hãy dành đúng 2 phút để ghi vào một bảng theo dõi (trên Notion, Obsidian hoặc Google Sheets) với 3 cột cốt lõi, tuyệt đối không dán nguyên cả đoạn code dài vào sổ tay:

Cột ghi chép Câu hỏi định hướng tư duy Ví dụ minh họa (Bài Subarray Sum Equals K)
1. Tín hiệu đề bài (Trigger) Chi tiết nào trong đề bài báo hiệu phải dùng cấu trúc dữ liệu này mà không dùng cấu trúc khác? Đề yêu cầu đếm đoạn con liên tiếp có tổng bằng \(K\), nhưng mảng có cả số âm \(\rightarrow\) Tổng không đơn điệu nên Cửa sổ trượt (Sliding Window) bị sai, bắt buộc dùng Mảng cộng dồn + Bảng băm.
2. Bất biến cốt lõi (Core Invariant) Một dòng phương trình toán học hoặc quy tắc duy trì cấu trúc dữ liệu là gì? Tại mỗi chỉ số \(r\), cần tìm số vị trí \(l \le r\) sao cho \(P[r] - P[l-1] = K \iff P[l-1] = P[r] - K\). Lưu tần suất của các \(P\) đã gặp vào Hash Map.
3. Bẫy biên từng vấp (Edge Pitfall) Lỗi nào khiến mình mất nhiều thời gian gỡ lỗi nhất ở lần làm đầu tiên? Quên khởi tạo freq[0] = 1 trước vòng lặp (dẫn đến bỏ sót các đoạn con bắt đầu ngay từ chỉ số \(0\) có tổng đúng bằng \(K\)).

Khi bạn cô đọng mỗi bài toán về đúng 3 câu ngắn gọn như trên, bộ não sẽ kết nối hàng chục bài toán rời rạc về chung một gốc tư duy (chẳng hạn nhóm các bài quy hoạch động 1 chiều cơ bản).

Lịch Ôn tập Ngắt quãng (Spaced Repetition SM-2) Chống Quên Bài LeetCode Mô phỏng cùng 1 bài Quy hoạch động qua 4 lần ôn với chuỗi điểm tự chấm q = [4, 5, 2, 4] Lần 1: q = 4 Tự code đúng, hơi chậm ở điều kiện biên Chu kỳ I_1 = 1 ngày EF giữ nguyên = 2.50 Lần 2: q = 5 Nhận diện mẫu ngay, code mượt dưới 15p Chu kỳ I_2 = 6 ngày EF tăng lên = 2.60 Lần 3: q = 2 (Quên) Nhớ mang máng, phải mở lời giải xem gợi ý Reset I_3 = 1 ngày! EF giảm còn = 2.28 Lần 4: q = 4 Ôn lại ngay hôm sau, tự viết lại trọn vẹn Chu kỳ I_4 = 1 ngày EF ổn định = 2.28 Nguyên tắc ghi Sổ tay Khuôn mẫu (Pattern Mistake Log) trong 3 dòng: 1. Tín hiệu nhận diện đề bài (Trigger) -> 2. Bất biến cốt lõi (Invariant) -> 3. Bẫy biên từng vấp (Pitfall). Không bao giờ học thuộc lòng từng dòng code; hãy truy hồi lại ý tưởng trên trang giấy trắng (Active Recall).
Thuật toán SM-2 Ôn bài LeetCode Chuỗi tự chấm q = [4, 5, 2, 4] Lần 1 (q = 4): Tự giải đúng -> Hẹn ôn sau 1 ngày (EF = 2.50) Lần 2 (q = 5): Giải mượt < 15 phút -> Hẹn ôn sau 6 ngày (EF = 2.60) Lần 3 (q = 2): Phải nhìn gợi ý -> Reset về 1 ngày! (EF = 2.28) Lần 4 (q = 4): Khôi phục trí nhớ -> Hẹn ôn sau 1 ngày (EF = 2.28)
Hình 1: Minh họa chu kỳ giãn cách ngày ôn tập theo thuật toán SuperMemo SM-2 qua 4 lần tự đánh giá với chuỗi điểm chất lượng q = [4, 5, 2, 4].

Ứng dụng thuật toán Spaced Repetition (SM-2) để lên lịch ôn bài tự động

Thay vì ôn lại tất cả các bài theo một lịch cứng nhắc, thuật toán SuperMemo SM-2 (nền tảng của phần mềm thẻ ghi nhớ Anki) điều chỉnh khoảng cách ngày giữa hai lần ôn (\(I_k\), tính bằng ngày) dựa trên mức độ trôi chảy (\(q \in \{0, 1, 2, 3, 4, 5\}\)) mà bạn tự chấm sau mỗi lần làm bài và Hệ số dễ nhớ (\(EF\) — Easiness Factor, khởi tạo bằng \(2.50\)):

Thang tự chấm điểm chất lượng q sau khi làm một bài LeetCode

  • \(q = 5\) (Hoàn hảo): Nhận diện ngay khuôn mẫu trong 1 phút, tự viết code chạy đúng ngay lần đầu trong dưới 15 phút và nêu chuẩn xác độ phức tạp Big-O.
  • \(q = 4\) (Tốt): Tự giải ra hướng tối ưu và code AC không cần xem gợi ý, nhưng mất vài phút xử lý điều kiện biên nhỏ.
  • \(q = 3\) (Vừa đủ qua): Tự nghĩ ra thuật toán đúng nhưng cài đặt còn lúng túng hoặc phải sửa lỗi 2–3 lần mới qua hết test.
  • \(q = 2\) (Quên một phần): Nhớ mang máng tên thuật toán nhưng tắc ở công thức chuyển trạng thái, phải mở Sổ tay đọc lại dòng gợi ý mới code tiếp được.
  • \(q \le 1\) (Quên hoàn toàn): Phải đọc lại toàn bộ lời giải mẫu từ đầu.

Quy tắc cập nhật khoảng cách ngày ôn (I) và Hệ số dễ nhớ (EF)

  1. Nếu bạn phải nhìn gợi ý (\(q \lt 3\)): Chuỗi ghi nhớ bị đứt gãy, đặt lại số lần nhớ liên tiếp \(\text{rep} = 0\) và ép lịch ôn lại ngay ngày hôm sau (\(I = 1\text{ ngày}\)).
  2. Nếu bạn tự giải thành công (\(q \ge 3\)): Tăng số lần nhớ liên tiếp \(\text{rep} \leftarrow \text{rep} + 1\):
    • Lần nhớ đầu tiên (\(\text{rep} = 1\)): \(I_1 = 1\text{ ngày}\).
    • Lần nhớ thứ hai (\(\text{rep} = 2\)): \(I_2 = 6\text{ ngày}\).
    • Từ lần thứ ba trở đi (\(\text{rep} \ge 3\)): \(I_k = \text{round}(I_{k-1} \times EF)\), với \(EF\) là hệ số trước khi cập nhật ở bước 3 (như mã giả SM-2) và phần lẻ \(0.5\) được làm tròn lên.
  3. Cập nhật hệ số \(EF\) sau mỗi lần ôn (giữ sàn tối thiểu \(EF \ge 1.30\)): \[EF' = \max\Big(1.30,\; EF + 0.1 - (5 - q) \times \big(0.08 + (5 - q) \times 0.02\big)\Big)\]

Chạy tay (Dry-run) lịch ôn của một bài Quy hoạch động qua 4 chu kỳ

Giả sử bạn ôn một bài Quy hoạch động với chuỗi điểm tự chấm qua 4 lần lần lượt là \(q = [4, 5, 2, 4]\) (khởi tạo \(\text{rep} = 0\), \(I_0 = 0\), \(EF_0 = 2.50\)):

Lần ôn Điểm tự chấm \(q\) Số lần nhớ liên tiếp (\(\text{rep}\)) Khoảng cách tới lần ôn tiếp theo (\(I\)) Hệ số dễ nhớ mới (\(EF'\)) Hành động thực tế của người học
Lần 1 \(q = 4\) \(0 \rightarrow 1\) \(1\text{ ngày}\) \(2.50 + 0.00 = \mathbf{2.50}\) Giải đúng lần đầu \(\rightarrow\) Hẹn ngày mai nhẩm lại
Lần 2 \(q = 5\) \(1 \rightarrow 2\) \(6\text{ ngày}\) \(2.50 + 0.10 = \mathbf{2.60}\) Code cực mượt \(\rightarrow\) Giãn lịch ra tuần sau
Lần 3 \(q = 2\) (Quên!) \(2 \rightarrow 0\) (Reset) \(1\text{ ngày}\) \(2.60 - 0.32 = \mathbf{2.28}\) Phải xem gợi ý \(\rightarrow\) Bắt buộc làm lại vào ngày mai!
Lần 4 \(q = 4\) \(0 \rightarrow 1\) \(1\text{ ngày}\) \(2.28 + 0.00 = \mathbf{2.28}\) Đã tự code lại được mà không cần nhìn tài liệu

Nếu ở Lần 5, Lần 6 và Lần 7 tiếp theo bạn đều đạt \(q = 5\), khoảng cách ôn tập sẽ tự động giãn ra thành \(6\text{ ngày} \rightarrow 14\text{ ngày} \rightarrow 35\text{ ngày}\) (\(\text{round}(6 \times 2.38) = 14\), \(\text{round}(14 \times 2.48) = 35\)). Chương trình dưới đây (C++17, Python, Java 21) cài đúng 3 quy tắc trên và in một dòng cho mỗi lần ôn. Chạy không có đầu vào, nó dùng chuỗi \(q = [4, 5, 2, 4]\) của bảng và in đúng 4 dòng #1 q=4 rep=1 I=1 EF=2.50, #2 q=5 rep=2 I=6 EF=2.60, #3 q=2 rep=0 I=1 EF=2.28, #4 q=4 rep=1 I=1 EF=2.28. Hệ số \(EF\) được lưu theo phần trăm (250 nghĩa là 2.50) nên mọi phép tính đều là số nguyên, không vướng sai số làm tròn của số thực:

// Bộ lập lịch ôn tập SM-2 theo đúng 3 quy tắc ở mục "Quy tắc cập nhật" của bài: sau mỗi lần ôn in số lần nhớ liên tiếp
// rep, khoảng cách I (ngày) tới lần ôn sau và hệ số dễ nhớ EF mới.
// Đầu vào: n, rồi n điểm tự chấm q (0..5). Không có đầu vào thì dùng q = [4, 5, 2, 4] của bảng.
// EF lưu theo phần trăm (250 nghĩa là 2.50) để tính bằng số nguyên; round(I x EF) làm tròn nửa lên, dùng EF trước khi
// cập nhật ở quy tắc 3.
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;

vector<string> lap_lich(const vector<int>& qs) {
    long long rep = 0, khoang = 0, ef = 250;
    vector<string> dong;
    for (size_t lan = 1; lan <= qs.size(); ++lan) {
        int q = qs[lan - 1];
        if (q >= 3) {  // Quy tắc 2: tự giải được
            ++rep;
            if (rep == 1) khoang = 1;
            else if (rep == 2) khoang = 6;
            else khoang = (khoang * ef + 50) / 100;  // round(I x EF)
        } else {  // Quy tắc 1: phải nhìn gợi ý, học lại từ đầu
            rep = 0;
            khoang = 1;
        }
        long long d = 5 - q;  // Quy tắc 3: EF' = max(1.30, EF + 0.1 - (5 - q)(0.08 + (5 - q) 0.02))
        ef = max(130LL, ef + 10 - d * (8 + 2 * d));
        ostringstream out;
        out << "#" << lan << " q=" << q << " rep=" << rep << " I=" << khoang << " EF=" << ef / 100 << "."
            << setw(2) << setfill('0') << ef % 100;
        dong.push_back(out.str());
    }
    return dong;
}

int main() {
    vector<int> qs;
    int n;
    if (!(cin >> n)) {
        qs = {4, 5, 2, 4};
    } else {
        qs.resize(n);
        for (int& q : qs) cin >> q;
    }
    for (const string& d : lap_lich(qs)) cout << d << "\n";
    return 0;
}

Kỹ thuật "Ôn nhanh 5 phút trên giấy trắng" cho người bận rộn

Khi danh sách bài đã học lên tới 100–150 bài, mỗi ngày bạn có thể có từ 5 đến 8 bài đến hạn ôn tập theo lịch SM-2. Nếu bài nào cũng ngồi gõ code từ đầu đến cuối sẽ mất tới 3 tiếng đồng hồ. Để tiết kiệm thời gian mà vẫn kích hoạt tối đa cơ chế Active Recall, hãy chia 2 cấp độ ôn tập:

  • Với các bài lần trước bị điểm thấp (\(q \le 3\)): Bắt buộc mở trình soạn thảo trống (tắt gợi ý tự động Autocomplete) và tự gõ lại toàn bộ code cho đến khi vượt qua toàn bộ bộ test.
  • Với các bài đã nắm vững (\(q \ge 4\)): Thực hiện Truy hồi Khung 5 phút (5-Minute Whiteboard Recall) cho mỗi bài:
    1. Đọc lại đề bài trong 60 giây.
    2. Viết ra giấy nháp đúng 3 thứ: (a) Cấu trúc dữ liệu sử dụng, (b) Phương trình chuyển trạng thái hoặc điều kiện dịch chuyển con trỏ (khoảng 5–8 dòng mã giả cốt lõi), và (c) Độ phức tạp Thời gian / Không gian.
    3. Mở Sổ tay Khuôn mẫu 3 dòng ra đối chiếu. Nếu khớp hoàn toàn cả thuật toán lẫn bẫy biên, bạn chấm ngay \(q = 5\) và chuyển sang bài tiếp theo chỉ sau 5 phút!

Luyện ngay trên Big-O Coding

Quy hoạch động (Dynamic Programming) là nhóm chủ đề dễ bị quên công thức chuyển trạng thái nhất nếu không ôn tập ngắt quãng; hãy áp dụng ngay phương pháp Sổ tay Khuôn mẫu 3 dòng cho 3 bài toán Quy hoạch động kinh điển dưới đây:

Khi giải một bài mới bị bí hoàn toàn thì nên suy nghĩ tối đa bao lâu trước khi mở gợi ý?

Ngưỡng thời gian vàng là 25 đến 30 phút. Nếu sau 25 phút vẽ nháp mà bạn vẫn chưa tìm ra hướng khả thi, việc ngồi nhìn màn hình thêm 2 tiếng nữa thường chỉ gây mệt mỏi mà không tăng thêm kiến thức. Lúc này, đừng đọc ngay toàn bộ code mẫu! Hãy mở từng tầng gợi ý nhỏ: đọc Tên chủ đề / Tag trước \(\rightarrow\) suy nghĩ thêm 10 phút \(\rightarrow\) đọc Ý tưởng cấp cao (High-level Intuition) \(\rightarrow\) rồi tự mình cài đặt thành code. Và nhớ chấm bài đó mức \(q = 1\) hoặc \(q = 2\) để bắt buộc tự giải lại từ trang giấy trắng vào sáng hôm sau.

Nên học dứt điểm từng chủ đề (Topic-by-Topic) hay giải trộn lẫn ngẫu nhiên (Random Shuffle)?

Bạn cần kết hợp cả hai theo 2 giai đoạn rõ rệt:

  • Giai đoạn 1 (Xây nền — 60% thời gian đầu): Học theo từng chủ đề (Topic-by-Topic). Làm liên tiếp 8–10 bài cùng thuộc chủ đề Cửa sổ trượt hoặc Tìm kiếm nhị phân giúp não bộ nhận ra quy luật chung rất nhanh.
  • Giai đoạn 2 (Luyện phản xạ phỏng vấn — 40% thời gian cuối): Bắt buộc phải giải trộn lẫn ngẫu nhiên (Blind / Random Mode) không nhìn Tag chủ đề. Bởi vì khi đi phỏng vấn thật, không ai nói trước cho bạn biết "Bài này dùng Quy hoạch động nhé", nên việc tự nhận diện đúng khuôn mẫu từ đề bài thô là kỹ năng quyết định.
Ôn lại bài cũ thì nên code lại bằng cùng một ngôn ngữ hay đổi sang ngôn ngữ khác?

Trong suốt quá trình chuẩn bị phỏng vấn, bạn nên kiên định với đúng 1 ngôn ngữ chủ lực duy nhất (C++17, Python hoặc Java) để đạt độ phản xạ gõ code tự nhiên như hơi thở. Thay vì đổi ngôn ngữ lập trình khi ôn bài cũ, hãy thử cài đặt bài toán đó bằng cách tiếp cận thứ hai (ví dụ: lần 1 giải bằng Đệ quy có nhớ Top-Down, lần ôn thứ 2 giải bằng Quy hoạch động lặp Bottom-Up tối ưu bộ nhớ từ \(\mathcal{O}(N)\) xuống \(\mathcal{O}(1)\)).

Muốn học bài bản cùng giảng viên?

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.

Xem Khóa LeetCode

Nguồn tham khảo

Chia sẻ: Facebook LinkedIn
Nhắn Zalo tư vấnZalo Gọi 0937 401 483