Problem involves pairs, sorted arrays, triplets, or opposite-end traversal.

Problem uses words like “window of size k”, “longest”, “shortest”, or “at most K”.

Problem talks about range sum, subarray sum, cumulative sum, or prefix-based queries.

Problem asks for maximum/minimum sum or product of a contiguous subarray.

Problem talks about palindrome checks, symmetric comparison, or reversing from both ends.

Problem uses words like longest, shortest, substring, at most K, exactly K.

Problem mentions a sorted array or “find element efficiently.”

Problem mentions first/last occurrence, bounds, or constraints on index.

Problem mentions minimum/maximum feasible value or optimization over a range.

Problem mentions 2D matrix, row/column sorted, or kth smallest element.

Problem mentions “next greater/smaller element,” spans, or trapping area.

Problem involves evaluating arithmetic expressions, parentheses, or decoding strings.

Problem mentions “undo,” “remove duplicates,” or “backspace string” operations.

Problem mentions parentheses, balanced brackets, scoring, or generation.

Problem mentions designing stack/queue systems or custom operations.

Problems asking for smallest/largest sequence, removing k elements

Problem mentions reverse/insert/delete recursively, sort stack, merge lists, or check palindrome recursively.

Problems requiring repetitive smaller tasks without splitting into multiple branches.

Problems where each step leads to multiple possibilities, such as Fibonacci sequences or finding unique paths on a grid.

Sorting, searching in structured data, reducing complexity logarithmically.

Problems asking to reverse, delete, or merge standard linear data structures.

Problems asking for subsets, combinations, or subsequences.

Problem mentions insertion, deletion at head/tail/Nth node or traversal.

Problem involves loops, cycle detection, or middle node operations.

Problem mentions reversing nodes or rearranging linked list order.

Problem mentions merging, sorting, or reordering linked lists.

Problem mentions reverse order processing or “next greater” style operations.

Problem mentions insertion/deletion in DLL, printing forwards/backwards, or caching (LRU/MRU/frequency-based).

Problem involves multi-level DLL, sorting, alternating nodes, palindrome check, conversions, or pair sums.

Problem mentions frequency, duplicates, top-k, or counting occurrences.

Problem involves subarray sums, cumulative sums, or “sum equals K”.

Problem mentions substring/window with constraints on counts or distinct elements.

Problem mentions “visit all nodes recursively, max depth/path/subtree sum.”

Problem mentions “level-order, breadth-first, zigzag, right-side view, or level sum/average.”

Problem mentions “find common ancestor, distance between nodes, or lowest node covering two nodes.”

Problem mentions “serialize tree, flatten tree to list, next pointers, or reconstruct tree.”

Problem mentions “BST operations, validate BST, insert/delete nodes, or sum/range queries.”

Problem mentions “find lowest common ancestor in BST, nodes guaranteed to exist, exploit BST order.”

Problem mentions “shortest path, level-order traversal, or unweighted distance”.

Problem mentions “connected components, islands, cycles, safe states, bipartite check, bridges, articulation points, or connectivity check”.

Problem mentions “ordering tasks, course prerequisites, dependency chains, build order, or cycle in directed graph”.

Problem mentions “minimum cost to connect all nodes, redundant connections, union-find required”.

Problem mentions “weighted edges, shortest path, or minimum distance in weighted graph”.

Problem mentions “negative weights, cycles, or cost minimization with negative edges”.

Problem mentions “all-pairs shortest paths, matrix, or city connectivity between any two nodes”.

Problem mentions top k, kth largest/smallest, median, or maintaining running extremes.

Problem mentions merging sorted arrays/lists or finding K smallest/largest pairs across arrays.

Problem mentions sliding window maximum/minimum or frequency-based window queries.

Design Priority Queue

Repeatedly combine the two smallest elements to minimize the total cost.

This approach forms a recursion tree and is the backbone of backtracking problems.

Problem mentions “generate all subsets, combinations, parentheses, letters from digits, or selection without rearranging order.”

Problem mentions “maze, grid, pathfinding, sudoku, word search in grid, Hamiltonian path, or max path gold.”

Problems where you recursively build sequences, combinations of digits/letters, or expressions.

Problem mentions “maximum non-overlapping intervals, tasks, meetings, jump to end, minimum steps, or cover intervals”.

Problem mentions “maximize/minimize sum, select elements optimally, assign/distribute resources, or custom order”.

Problem mentions “subarrays, sequences, max/min sum/product, or linear decisions”.

Problem mentions “grids, movement from start to end, paths, or matrix-based sums”.

Problem mentions “subsequence, substring, longest common, palindrome, or string edit operations”.

Problem mentions “intervals, subarray partitions, merging cost, or burst balloons”.

Problem mentions “trees, DAGs, path sums, node coverage, or ways to traverse dependent nodes”.

Problem mentions “choose subset under constraints, maximize value, target sum, or weight limit”.

Problems involving buying and selling stocks to maximize profit with varying constraints.

Problem mentions “dictionary, prefix search, word lookup, autocomplete, or predictive text”.

Problem mentions “word segmentation, dictionary words, concatenated words, or string break”.

Problem mentions “maximize XOR, XOR queries, bit-level optimization, or subsets”.

Problem mentions “unique element, missing number, or bit counting”.

Problem mentions “generate subsets, combinations, or mask enumeration”.

Problem mentions “maximize XOR, XOR queries, pairs, or range XOR”.