From Zero to LeetCode Success: A 50‑Year‑Old’s Guide to Effective Algorithm Practice

While browsing Little Red Book, the author saw a 50‑year‑old aunt celebrating her first successful LeetCode submission, feeling both fun and excitement. The post sparked curiosity about how a complete beginner can effectively practice algorithm problems.

The article outlines a systematic method for newcomers to start solving LeetCode questions, emphasizing the importance of choosing a problem you like and avoiding endless platform comparisons.

Just like the 50‑year‑old aunt, pick a problem that appeals to you.

Do not waste time debating whether LeetCode or other sites are better; focus on consistent practice on a single platform.

1. Accept That You Are an Algorithm Beginner

The author admits that early attempts involved superficial learning of data structures and algorithms without applying them to real problems. Trying to prove oneself with overly clever solutions led to frustration and a sense of hopelessness.

Recognizing one’s beginner status and accepting brute‑force methods as a valid starting point helps build confidence.

2. Adopt a Reasonable Practice Routine

Blindly chasing quantity—solving hundreds of problems without depth—produces confusion. Instead, thoroughly understand each problem before moving on.

Write your own solution.

Study a high‑quality online solution.

Identify improvement points in your own code.

Continuously optimize.

Find similar problem types and practice them repeatedly.

Summarize the insights.

Each problem should undergo at least one iteration of this cycle, leading to mastery of that problem type.

As an example, the article examines LeetCode problem #70 “Climbing Stairs,” a simple dynamic‑programming task. Initially unaware of DP concepts, the author implemented a naïve recursive solution:

class Solution {
    public int climbStairs(int n) {
        return calcWays(n);
    }
    private int calcWays(int n) {
        if (n == 1) return 1;
        if (n == 2) return 2;
        return calcWays(n-1) + calcWays(n-2);
    }
}

This brute‑force approach repeats many sub‑computations and exceeds the time limit.

After learning about memoization, the author rewrote the solution to store intermediate results:

// Use memoization to avoid repeated calculations
class Solution {
    int[] memo;
    public int climbStairs(int n) {
        memo = new int[n+1];
        return calcWays(n);
    }
    private int calcWays(int n) {
        if (n == 1) return 1;
        if (n == 2) return 2;
        if (memo[n] == 0)
            memo[n] = calcWays(n-1) + calcWays(n-2);
        return memo[n];
    }
}

Recognizing that memoization is a top‑down DP technique, the author further transformed it into a bottom‑up iterative DP solution:

class Solution {
    public int climbStairs(int n) {
        int[] memo = new int[n+1];
        memo[0] = 1;
        memo[1] = 1;
        for (int i = 2; i <= n; i++) {
            memo[i] = memo[i-1] + memo[i-2];
        }
        return memo[n];
    }
}

Following this structured practice path, the author gained a clear thinking process for this type of problem, reducing the time spent staring at a statement to merely half an hour before coding.

After mastering the “Climbing Stairs” pattern, the author recommends repeatedly practicing similar DP problems such as Minimum Path Sum, Integer Break, Perfect Squares, Decode Ways, Unique Paths, and Unique Paths II. By identifying commonalities across these problems, one gradually internalizes concepts like optimal substructure, state transition, and overlapping subproblems, eventually mastering about 80% of DP knowledge.

When encountering more challenging DP questions, the author now checks whether the difficulty stems from unclear substructure, transition equations, or overlapping subproblems. Consistent, focused practice builds confidence and enables smooth handling of new problem types.

The article concludes with encouragement for readers to find the same joy in problem‑solving that the 50‑year‑old aunt experienced.