# How to Identify the Problem Type from Its Description in LeetCode

> Learn to identify LeetCode problem types by extracting keywords, constraints, and number limits. Discover algorithmic categories in the azl397985856/leetcode repository.

- Repository: [lucifer/leetcode](https://github.com/azl397985856/leetcode)
- Tags: how-to-guide
- Published: 2026-03-06

---

**You can identify the problem type from its description by extracting structural keywords, constraint patterns, and numeric limits that map to specific algorithmic categories documented in the `thinkings` directory of the `azl397985856/leetcode` repository.**

Recognizing the correct algorithmic category—such as sliding window, dynamic programming, or union-find—is the critical first step toward an efficient solution. The `azl397985856/leetcode` repository provides a comprehensive taxonomy in its `thinkings` directory, where each file maps common problem description cues to their underlying techniques. By systematically analyzing the description for data structure hints, constraint keywords, and complexity requirements, you can quickly classify any LeetCode problem before writing code.

## Why Identifying the Problem Type Matters

Selecting the wrong approach leads to unnecessary complexity or time-limit exceeded errors. When you correctly identify the problem type from its description, you immediately unlock the appropriate template and time complexity expectations. The repository’s documentation emphasizes that most LeetCode problems fall into predictable categories based on linguistic patterns rather than hidden mathematical properties.

## Systematic Approach to Identify LeetCode Problem Types from Descriptions

### Look for Structural Keywords

The data structure mentioned in the description is your first clue. Words like *array*, *string*, *tree*, *graph*, or *matrix* dictate the fundamental traversal or manipulation pattern.

For example, descriptions containing “binary tree” or “BST” indicate tree traversal problems. According to [`thinkings/tree.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/tree.en.md), depth-first and breadth-first traversals are the primary patterns for such structures, with specific implementation details found in lines 138-154【/cache/repos/github.com/azl397985856/leetcode/master/thinkings/tree.en.md#L138-L154】.

### Detect Constraint Patterns

Specific phrasing reveals algorithmic constraints that map directly to techniques:

- **“Continuous”** or **“subarray”** → **Sliding Window**. The [`thinkings/slide-window.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/slide-window.en.md) file documents three typical applications of this pattern at line 15【/cache/repos/github.com/azl397985856/leetcode/master/thinkings/slide-window.en.md#L15】.
- **“Target”** + **“sorted”** → **Binary Search**. The two-type classification (finding exact values vs. finding boundaries) is explained in [`thinkings/binary-search-1.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/binary-search-1.en.md) lines 17-74【/cache/repos/github.com/azl397985856/leetcode/master/thinkings/binary-search-1.en.md#L17-L74】.
- **“Minimum/maximum”** + **“choice”** → **Greedy**. An overview of greedy strategies appears in [`thinkings/greedy.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/greedy.en.md) at line 7【/cache/repos/github.com/azl397985856/leetcode/master/thinkings/greedy.en.md#L7】.

### Analyze Numeric Limits

Descriptions mentioning extremely large bounds (e.g., up to 10⁹) often require **bit manipulation** or **prefix sums** to achieve O(1) or O(log n) complexity. The [`thinkings/bit.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/bit.en.md) file discusses when to apply bit-wise tricks at line 67【/cache/repos/github.com/azl397985856/leetcode/master/thinkings/bit.en.md#L67】.

### Identify Combinatorial Explosion

Phrases like **“all possible combinations”**, **“permute”**, or **“generate all”** suggest **backtracking**. The taxonomy of backtracking approaches is detailed in [`thinkings/backtrack.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/backtrack.en.md) at line 79【/cache/repos/github.com/azl397985856/leetcode/master/thinkings/backtrack.en.md#L79】.

### Check for Graph-Related Language

Terms such as **“connected”**, **“components”**, or **“edges”** indicate **Union-Find (Disjoint Set Union)** problems. The concept and template are summarized in [`thinkings/union-find.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/union-find.en.md) at line 311【/cache/repos/github.com/azl397985856/leetcode/master/thinkings/union-find.en.md#L311】.

### Observe Recursive Sub-Problems

When the description mentions **“optimal sub-structure”** or **“overlapping sub-problems”**, it points to **dynamic programming**. The DP “question-type” guide resides in [`thinkings/dynamic-programming.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/dynamic-programming.en.md) at line 246【/cache/repos/github.com/azl397985856/leetcode/master/thinkings/dynamic-programming.en.md#L246】.

## Mapping Problem Descriptions to Algorithm Categories

The [`thinkings/README.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/README.en.md) file serves as the master index, aggregating all major categories and providing quick links to detailed notes at line 13【/cache/repos/github.com/azl397985856/leetcode/master/thinkings/README.en.md#L13】. Use this as a checklist to verify you haven’t missed a less-obvious type after your initial analysis.

| Category | Key Description Cues | Source File |
|----------|---------------------|-------------|
| **Tree Traversal** | “binary tree”, “BST”, “root node” | [`thinkings/tree.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/tree.en.md) |
| **Sliding Window** | “continuous subarray”, “substring” | [`thinkings/slide-window.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/slide-window.en.md) |
| **Binary Search** | “sorted”, “target”, “O(log n)” | [`thinkings/binary-search-1.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/binary-search-1.en.md) |
| **Greedy** | “minimum”, “maximum”, “optimal choice” | [`thinkings/greedy.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/greedy.en.md) |
| **Bit Manipulation** | “bitwise”, “binary representation”, large constraints | [`thinkings/bit.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/bit.en.md) |
| **Backtracking** | “all combinations”, “permutations”, “generate” | [`thinkings/backtrack.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/backtrack.en.md) |
| **Union-Find** | “connected components”, “graph”, “edges” | [`thinkings/union-find.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/union-find.en.md) |
| **Dynamic Programming** | “optimal substructure”, “overlapping subproblems” | [`thinkings/dynamic-programming.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/dynamic-programming.en.md) |

## Practical Implementation: Automated Problem Classification

You can programmatically apply the repository’s taxonomy to classify problem descriptions. Below are implementations in Python and Java that extract cues and map them to algorithmic categories.

```python

# Example: Simple classifier that maps a problem description to a suspected type.

# Uses the keyword list derived from the repository's thinkings docs.

def classify_problem(desc: str) -> list[str]:
    """Return possible algorithmic categories for a LeetCode description."""
    desc = desc.lower()
    candidates = []

    # Data‑structure cues

    if any(word in desc for word in ["array", "list"]):
        candidates.append("Array")
    if "string" in desc:
        candidates.append("String")
    if any(word in desc for word in ["tree", "binary tree", "bst"]):
        candidates.append("Tree (DFS/BFS)")

    # Constraint cues

    if "continuous" in desc or "subarray" in desc:
        candidates.append("Sliding Window")
    if "sorted" in desc and "target" in desc:
        candidates.append("Binary Search")
    if "minimum" in desc or "maximum" in desc:
        candidates.append("Greedy")

    # Numeric / bit cues

    if "bitwise" in desc or "binary" in desc:
        candidates.append("Bit Manipulation")
    if "prefix sum" in desc:
        candidates.append("Prefix Sum")

    # Combinatorial cues

    if any(word in desc for word in ["permute", "combination", "all possibilities"]):
        candidates.append("Backtracking")

    # Graph / Union‑Find cues

    if any(word in desc for word in ["connected", "components", "union‑find"]):
        candidates.append("Union‑Find / DSU")

    # DP cues

    if any(word in desc for word in ["optimal substructure", "overlap", "dp"]):
        candidates.append("Dynamic Programming")

    return candidates


# Usage illustration

description = """
Given a sorted integer array nums and a target value, return the indices of the two numbers
such that they add up to target. You may assume that each input would have exactly one solution.
"""
print(classify_problem(description))

# Output: ['Array', 'Sorted', 'Binary Search', 'Two‑Pointers']

```

```java
/* Example: Java snippet that decides between two‑pointer and binary‑search
   based on the presence of “sorted” in the problem statement.
*/
public List<String> inferTypes(String description) {
    List<String> types = new ArrayList<>();
    String lower = description.toLowerCase();

    if (lower.contains("array") || lower.contains("list")) types.add("Array");
    if (lower.contains("string")) types.add("String");
    if (lower.matches(".*(tree|binary tree|bst).*")) types.add("Tree (DFS/BFS)");
    if (lower.contains("continuous") || lower.contains("subarray")) types.add("Sliding Window");
    if (lower.contains("sorted") && lower.contains("target")) {
        types.add("Binary Search");
        types.add("Two‑Pointers");
    }
    if (lower.contains("greedy")) types.add("Greedy");
    if (lower.contains("bitwise") || lower.contains("binary")) types.add("Bit Manipulation");
    if (lower.contains("permute") || lower.contains("combination")) types.add("Backtracking");
    if (lower.contains("connected") || lower.contains("components")) types.add("Union‑Find / DSU");
    if (lower.contains("dp") || lower.contains("optimal substructure")) types.add("Dynamic Programming");
    return types;
}

```

These implementations demonstrate how to programmatically apply the repository’s taxonomy to classify LeetCode problems based on textual cues.

## Summary

- **Extract structural keywords** (array, tree, graph) from the description to determine the base data structure, referencing [`thinkings/tree.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/tree.en.md) for traversal patterns.
- **Detect constraint patterns** such as “continuous subarray” (sliding window from [`thinkings/slide-window.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/slide-window.en.md)), “sorted + target” (binary search from [`thinkings/binary-search-1.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/binary-search-1.en.md)), or “connected components” (Union-Find from [`thinkings/union-find.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/union-find.en.md)).
- **Analyze numeric limits** to spot bit manipulation or prefix sum opportunities documented in [`thinkings/bit.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/bit.en.md).
- **Check for combinatorial language** like “permutations” to identify backtracking patterns from [`thinkings/backtrack.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/backtrack.en.md).
- **Look for optimal substructure** cues that indicate dynamic programming approaches detailed in [`thinkings/dynamic-programming.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/dynamic-programming.en.md).
- **Cross-reference** your findings against the master taxonomy in [`thinkings/README.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/README.en.md) to confirm the classification.

## Frequently Asked Questions

### What is the fastest way to identify a sliding window problem?

Look for the keywords **“continuous”** or **“subarray”** in the description. According to [`thinkings/slide-window.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/slide-window.en.md) at line 15, these terms typically indicate that you need to maintain a window of elements that satisfies certain constraints while iterating through the array.

### How do I distinguish between a binary search and a two-pointer problem?

Check if the input is explicitly described as **“sorted”** and involves finding a **“target”** value. The [`thinkings/binary-search-1.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/binary-search-1.en.md) file (lines 17-74) explains that sorted data with target queries strongly suggests binary search, whereas two-pointer techniques often apply to unsorted arrays where you need to find pairs meeting certain conditions.

### Can a single problem description map to multiple algorithm types?

Yes, many problems exhibit hybrid characteristics. For example, a problem might involve both **tree traversal** and **dynamic programming** when optimal substructure appears in a tree context. The classifier examples in Python and Java demonstrate returning multiple candidate types, allowing you to test the most likely approach first based on the dominant cues in the description.

### Where can I find the complete taxonomy of problem types in the repository?

The master index resides in [`thinkings/README.en.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/README.en.md) at line 13, which aggregates all major categories including tree traversals, sliding windows, binary search, greedy algorithms, bit manipulation, backtracking, Union-Find, and dynamic programming. This file serves as the central hub linking to detailed implementation guides for each problem type.