Mixed Pattern Problems

The 5-Step Problem Solving Framework

1. Read & Understand (2 min): Read the problem twice. Identify input/output, constraints, and edge cases.
2. Identify Pattern (3 min): Look for keywords that signal specific patterns.
3. Plan Approach (3 min): Outline your solution before coding.
4. Code (15-20 min): Write clean, modular code.
5. Test & Optimize (5 min): Walk through examples and edge cases.

Pattern Signal Words

Pattern	Signal Words
Two Pointers	sorted, pair, palindrome, swap
Sliding Window	subarray, substring, consecutive, contiguous
Binary Search	sorted, find minimum/maximum, k-th element
DFS/BFS	tree, graph, connected, path, level
Dynamic Programming	count ways, minimum/maximum, can you, overlapping subproblems
HashMap	frequency, duplicate, two sum, anagram
Stack	parentheses, next greater, histogram, monotonic
Greedy	interval, activity, task, schedule
Union-Find	connected components, merge, group
Topological Sort	dependency, prerequisite, task ordering

Java Template for Quick Pattern Selection

// Common imports you'll need
import java.util.*;
import java.util.stream.*;

// When you see 'sorted array' + 'pair' -> Two Pointers
int left = 0, right = arr.length - 1;
while (left < right) {
    int sum = arr[left] + arr[right];
    if (sum == target) return new int[]{left, right};
    else if (sum < target) left++;
    else right--;
}

// When you see 'subarray' + 'sum/length' -> Sliding Window
int windowSum = 0, maxSum = 0;
for (int i = 0; i < k; i++) windowSum += arr[i];
maxSum = windowSum;
for (int i = k; i < arr.length; i++) {
    windowSum += arr[i] - arr[i - k];
    maxSum = Math.max(maxSum, windowSum);
}

// When you see 'tree' + 'path/depth' -> DFS
int depth(TreeNode node) {
    if (node == null) return 0;
    return 1 + Math.max(depth(node.left), depth(node.right));
}

Pattern 1: DFS + Backtracking

// Example: Generate all permutations
List<List<Integer>> permute(int[] nums) {
    List<List<Integer>> result = new ArrayList<>();
    backtrack(result, new ArrayList<>(), nums);
    return result;
}

void backtrack(List<List<Integer>> result, List<Integer> temp, int[] nums) {
    if (temp.size() == nums.length) {
        result.add(new ArrayList<>(temp));
        return;
    }
    for (int i = 0; i < nums.length; i++) {
        if (temp.contains(nums[i])) continue;
        temp.add(nums[i]);
        backtrack(result, temp, nums);
        temp.remove(temp.size() - 1);
    }
}

Pattern 2: HashMap + Sorting

// Example: Group anagrams
Map<String, List<String>> groupAnagrams(String[] strs) {
    Map<String, List<String>> map = new HashMap<>();
    for (String s : strs) {
        char[] chars = s.toCharArray();
        Arrays.sort(chars);
        String key = new String(chars);
        map.computeIfAbsent(key, k -> new ArrayList<>()).add(s);
    }
    return map;
}

Pattern 3: BFS + Graph

// Example: Level order traversal with BFS
List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> result = new ArrayList<>();
    if (root == null) return result;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        int size = queue.size();
        List<Integer> level = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            level.add(node.val);
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
        result.add(level);
    }
    return result;
}

Pattern 4: Binary Search + DP

// Example: Longest Increasing Subsequence (patience sorting)
int lengthOfLIS(int[] nums) {
    List<Integer> sub = new ArrayList<>();
    for (int x : nums) {
        if (sub.isEmpty() || sub.get(sub.size() - 1) < x) {
            sub.add(x);
        } else {
            int idx = Collections.binarySearch(sub, x);
            if (idx < 0) idx = -(idx + 1);
            sub.set(idx, x);
        }
    }
    return sub.size();
}

Interview Time Management

Phase	Time Budget	Activity
Understanding	2-3 min	Read problem, clarify constraints
Planning	3-5 min	Identify pattern, outline solution
Coding	15-20 min	Write clean code with comments
Testing	5 min	Walk through examples, edge cases
Optimization	2-3 min	Discuss Big-O, suggest improvements

Total: ~30 minutes per problem