DSA for Campus Placement Assessments

Choose among a set, value-frequency map, index map, and prefix-state map based on the query a solution must answer.

Transform target-sum or equal-count subarray problems into prefix-state frequency counting.

Validate a variable-size sliding window by stating its invariant and verifying that pointer movement is monotone.

Use sorting and two pointers for pair or triplet constraints that do not require preserving input order.

Preserve or reconstruct original indices when an optimized algorithm sorts or aggregates the input.

Implement lower-bound and upper-bound binary searches without off-by-one errors.

Recognize when a minimization or maximization problem can be reformulated as binary search on a monotone answer.

Merge or insert intervals after identifying the required sorted order.

Recognize next-greater, next-smaller, and span problems as monotonic-stack problems.

Maintain the best k candidates with a size-limited heap.

Use a heap to process the next item among multiple sorted frontiers.

Specify the information a tree DFS must return for a path or subtree problem.

Model a grid or transformation problem as an implicit graph with clearly defined states and transitions.

Choose BFS, topological sorting, or Dijkstra from the graph's edge weights and dependency properties.

Define a minimal DP state using only information needed by future decisions.

Derive a DP transition by enumerating the final decision that produces a state.

Reject an unsafe greedy rule by constructing a minimal counterexample.

Complete a 35-minute mixed mini-OA and record the pattern, complexity target, language choice, and stopping decision for each problem.

Use prefix and suffix summaries to avoid recomputing each removal, split, or product.

Apply Kadane's recurrence to maximum- and minimum-contiguous-sum variants.

Use in-place marking when values occupy a known index range and input mutation is permitted.

Transform circular-array conditions using doubled indexing or complementary subarrays.

Traverse a matrix by boundaries, directions, diagonals, or layers without skipping or duplicating cells.

Reduce an anagram, grouping, or matching condition to a canonical frequency signature.

Separate tokenization, normalization, and rule evaluation in string-processing problems.

Use XOR or a bit mask to encode parity or small-set membership in an array or string problem.

Derive an exact-count result as atMost(k) minus atMost(k-1) when validity is monotone in k.

Maintain multiple frequency requirements in a minimum-covering window.

Count valid subarrays by adding the number of valid left endpoints for each right endpoint.

Use a monotonic deque to maintain a window maximum or minimum.

Choose between same-direction and opposite-direction pointer movement from the ordering invariant.

Partition an array in place while preserving a stated region invariant.

Adapt two pointers to deduplicated pair, triplet, and closest-value variants.

Diagnose why negative values can invalidate a sliding window and substitute prefix-state counting when applicable.

Derive and justify a monotone feasibility predicate from a minimization or maximization objective.

Set provably sufficient low and high bounds for binary search on the answer.

Choose between sorting, a heap, and binary search for a kth-element problem.

Convert overlapping interval constraints into ordered start and end events.

Schedule non-overlapping tasks using a finish-time greedy rule.

Use a heap to allocate reusable resources across overlapping intervals.

Define tie-safe multi-key ordering with a C++ comparator or Python key function.

Justify a greedy choice using an invariant or exchange argument.

Implement iterative preorder, inorder, and postorder traversal using explicit stack state.

Compute a tree answer by combining independently calculated child summaries.

Track a global path answer separately from the extendable value returned to a parent.

Validate BST ordering using propagated lower and upper bounds.

Use inorder ordering to solve kth-element and predecessor-successor BST queries.

Find a lowest common ancestor using subtree membership or BST ordering.

Serialize and deserialize a binary tree using explicit null markers.

Recognize when level-order traversal must retain position, parent, or horizontal-distance metadata.

Implement iterative component traversal on a grid, marking cells in place when mutation is allowed.

Detect cycles in undirected and directed graphs using the appropriate traversal state.

Produce a topological order and detect an impossible dependency schedule.

Run multi-source BFS to compute the nearest source for every reachable state.

Implement Dijkstra with stale-entry handling for nonnegative weighted edges.

Use disjoint-set union for incremental connectivity and redundant-edge problems.

Carry stops, parity, keys, or another small attribute as part of an expanded graph state.

Solve a board-search problem with DFS, backtracking, and correct state restoration.

Distinguish the state shapes required by subsequence, subarray, partition, and grid DP problems.

Convert a recursive choice process into memoization using only decision-relevant state.

Convert a memoized recurrence into bottom-up tabulation with a valid evaluation order.

Reduce DP memory when each state depends on only a bounded number of earlier rows or states.

Derive a take-or-skip recurrence for subset-sum and knapsack variants.

Solve common longest-increasing-subsequence variants using the appropriate quadratic or binary-search method.

Prune a backtracking search using feasibility bounds and duplicate skipping.

Order backtracking choices to find valid or optimal candidates earlier without changing correctness.

Translate a long rule-based prompt into an explicit state machine.

Separate parsing, state updates, and output formatting in a simulation problem.

State and preserve an invariant across every step of a simulation.

Use language-appropriate numeric safety for products, counts, midpoints, and distances.

Produce a brute-force model and identify its exact performance bottleneck before optimizing it.

Complete a 45-minute mixed mini-OA using expected-value triage and a predefined no-progress pivot rule.

Classify each timed-set miss as a recognition, algorithm, implementation, language-choice, or time-allocation failure.

Convert a timed-set postmortem into a ranked plan for the next day's drills.