Quartz 4

Graph Algorithms

7 min read

Graph Algorithms - Processing Complete

[Graph algorithm insights have been moved to individual Zettelkasten notes - 2025-08-03]

Created Notes:

LeetCode Problem Analysis - Error Patterns and Learnings

Problem Database

1. Maximum Depth of N-ary Tree

URL: https://leetcode.com/problems/maximum-depth-of-n-ary-tree/ Difficulty: Easy Primary Category: Tree Traversal (DFS/BFS) Secondary Categories: Recursive problem solving, Base case handling, Edge case management Pattern: Tree property calculation (aggregate information from subtrees)

Errors Made:

  • Scope/Variable Binding: Confusion with globals()/locals() in inner functions
  • Edge Case - Data Structure States: Not considering node.children could be [] (empty list) vs None
  • Edge Case - Empty Sequences: Calling max() on empty sequence without handling base case
  • Variable Naming: Function parameter named root but referenced as node inside function

Error Categories:

  • Runtime vs Logic: Mostly runtime errors (variable naming, max() on empty, scope)
  • Preparation vs Implementation: Preparation error (data structure understanding)
  • Classic Interview Pitfall: Edge case enumeration failure

2. Range Sum of BST

URL: https://leetcode.com/problems/range-sum-of-bst/ Difficulty: Easy Primary Category: Binary Search Tree, Tree Traversal Secondary Categories: In-order traversal, Range queries, State management Pattern: BST range collection (must explore all nodes that could satisfy condition)

Errors Made:

  • Scope Resolution: Confused global and nonlocal keywords - assumed global would hoist to nearest enclosing scope like nonlocal
  • Incomplete Traversal Logic: When node value was in range, forgot to continue traversing both subtrees for additional matches

Error Categories:

  • Python Mechanics: Fundamental misunderstanding of LEGB scope resolution
  • Algorithmic Reasoning: Early termination anti-pattern (“found match, stop looking”)
  • Problem Type Confusion: Collection problem treated like pruning problem

8. Delete Leaves with a Given Value

URL: https://leetcode.com/problems/delete-leaves-with-a-given-value/ Difficulty: Medium Primary Category: Binary Tree, Tree Traversal Secondary Categories: Post-order traversal, Tree modification, Recursive deletion Pattern: Tree modification with bottom-up processing (post-order for safe deletion)

Errors Made:

  • None - problem solved successfully

Error Categories:

  • Success case - no error patterns to analyze

Success Factors:

  • Correct Traversal Choice: Likely identified need for post-order traversal (process children before parent)
  • Tree Modification Logic: Successfully handled node deletion without corrupting tree structure
  • Pattern Recognition: Understood that leaf deletion requires bottom-up approach
  • Consistent Success: Another clean solve in tree traversal domain

Technical Approach Note:

  • Post-order traversal ensures children are processed before deciding parent’s fate
  • Shows solid understanding of when different traversal orders are appropriate

7. Sum of Nodes With Even-Valued Grandparent

URL: https://leetcode.com/problems/sum-of-nodes-with-even-valued-grandparent/ Difficulty: Medium Primary Category: Binary Tree, Tree Traversal Secondary Categories: DFS, State passing, Multi-generation node relationships Pattern: Tree traversal with multi-level state tracking (parent → grandparent relationships)

Errors Made:

  • None - problem solved successfully

Error Categories:

  • Success case - no error patterns to analyze

Success Factors:

  • Clean State Management: Transferred state within function parameters instead of using global variables
  • Multi-level Thinking: Successfully tracked grandparent-parent-child relationships
  • Pattern Recognition: Identified need for state passing in recursive calls
  • Learning Applied: Avoided previous scope confusion issues by using parameter passing

Technical Approach Note:

  • Used function parameters to pass parent/grandparent state rather than global state
  • Shows evolution from earlier global/nonlocal scope issues

6. All Elements in Two Binary Search Trees

URL: https://leetcode.com/problems/all-elements-in-two-binary-search-trees/ Difficulty: Medium Primary Category: Binary Search Tree, Tree Traversal Secondary Categories: In-order traversal, Merge algorithms, Sorted array merging Pattern: BST to sorted sequence conversion + merge (leverages BST in-order property)

Errors Made:

  • Conceptual Terminology: Incorrectly stated using “preorder traversal” when actually implementing in-order traversal

Error Categories:

  • Knowledge Gap: Traversal order terminology confusion (know the implementation, wrong name)
  • Verbal/Conceptual Mismatch: Can implement correctly but mislabel the approach

Success Factors:

  • Correctly identified that BST + sorted sequence = in-order traversal (even if mislabeled)
  • Proper implementation despite terminology confusion
  • Good pattern recognition for merge-based approach

Learning Opportunities Identified:

  • Review traversal order definitions and characteristics
  • Learn Morris traversal for O(1) space complexity optimization

5. Deepest Leaves Sum

URL: https://leetcode.com/problems/deepest-leaves-sum/ Difficulty: Medium Primary Category: Binary Tree, Tree Traversal Secondary Categories: Level-order traversal, BFS, Tree depth calculation Pattern: Level-based tree processing (find specific level, then aggregate)

Errors Made:

  • None - problem solved successfully

Error Categories:

  • Success case - no error patterns to analyze

Success Factors:

  • Likely benefited from recent practice with level-order traversal concepts
  • Problem pattern recognition from previous tree problems
  • Proper constraint understanding and edge case handling

4. Count Nodes Equal to Average of Subtree

URL: https://leetcode.com/problems/count-nodes-equal-to-average-of-subtree/ Difficulty: Medium Primary Category: Binary Tree, Tree Traversal Secondary Categories: Post-order traversal, Subtree property calculation, Aggregation Pattern: Tree property calculation with subtree information (similar to Maximum Depth but with aggregation)

Errors Made:

  • Language Mechanics: Forgot that integer division in Python requires // instead of / which performs floating point arithmetic

Error Categories:

  • Python Language Fundamentals: Basic operator confusion
  • Implementation Layer: Knew the algorithm but used wrong syntax
  • Runtime vs Compilation: Would have been caught at runtime with wrong results, not syntax error

3. Reverse Odd Levels of Binary Tree

URL: https://leetcode.com/problems/reverse-odd-levels-of-binary-tree/ Difficulty: Medium Primary Category: Binary Tree, Level-order traversal Secondary Categories: Perfect binary tree properties, Tree modification Pattern: Level-based tree transformation

Errors Made:

  • Missing Problem Constraints: Didn’t recognize “perfect binary tree” constraint and its simplifying implications
  • Requirement Misunderstanding: Didn’t fully grasp what “reverse odd levels” meant operationally

Error Categories:

  • Problem Comprehension: Insufficient requirement analysis before coding
  • Constraint Utilization: Failed to leverage problem constraints for solution simplification
  • ADHD-Related: Likely rushed through problem reading phase

Error Pattern Analysis

Recurring Error Categories

1. API/Implementation Knowledge Gaps

  • Python queue interface confusion (deque methods)
  • Scope resolution (global vs nonlocal)
  • Data structure method names and parameters
  • Pattern: Know the concept, can’t express in code

2. Language Fundamentals/Operator Confusion

  • Integer division (//) vs floating point division (/) in Python
  • Pattern: Basic language mechanics forgotten under pressure
  • New Category: Fundamental operator/syntax confusion

3. Problem Comprehension Issues

  • Skipping constraint analysis (“perfect binary tree”)
  • Misunderstanding requirements (“reverse odd levels”)
  • Pattern: Solving wrong problem due to incomplete understanding

4. Edge Case Oversight

  • Empty collections vs None values
  • Empty sequences for aggregation functions (max, min)
  • Pattern: Incomplete enumeration of possible input states

5. Traversal Logic Errors

  • Premature termination (stopping when should continue)
  • Wrong traversal type selection (forgetting in-order exists)
  • Pattern: Mismatching algorithm to problem requirements

6. Variable Management

  • Inconsistent naming (root vs node)
  • Scope confusion in nested functions
  • Pattern: Implementation details causing runtime errors

7. Conceptual Terminology Gaps

  • Traversal order naming confusion (preorder vs in-order vs post-order)
  • Pattern: Can implement correctly but mislabel the approach
  • Risk: Could confuse interviewers or cause miscommunication

Meta-Categories

Two-Layer Problem Structure

  1. Problem-Solving Layer: Understanding what needs to be done
  2. Implementation Layer: Expressing solution in working code

Error Timing

  • Preparation Errors: Made before coding starts (problem misunderstanding)
  • Implementation Errors: Made during coding (syntax, API, logic)
  • Runtime Errors: Discovered when code executes (variable names, empty sequences)

Success Patterns Identified

  • When constraints were properly analyzed, solutions were more elegant
  • When traversal type was correctly identified, implementation was smoother
  • Global state usage worked well when scope was handled correctly
  • Recent addition: Level-order traversal pattern recognition improving with practice
  • Problem familiarity: Similar problems (tree depth, level processing) building on each other
  • Error learning: Previous mistakes with tree problems helping avoid repetition
  • State Management Evolution: Progressing from global state issues to clean parameter passing
  • Multi-level Problem Solving: Successfully handling parent-grandparent-child relationships
  • Traversal Order Mastery: Correctly choosing post-order for tree modification problems
  • Success Streak: Multiple consecutive clean solves showing consolidated learning

Evidence-Based Next Steps

High-Impact Interventions (based on recurring patterns):

  1. Python API Reference Sheet: Create spaced repetition cards for queue, stack, heap operations
  2. Python Operators Quick Reference: / vs //, and vs &, or vs |, etc.
  3. Tree Traversal Terminology Review: In-order, pre-order, post-order definitions and use cases
  4. Advanced Traversal Techniques: Learn Morris traversal for O(1) space complexity
  5. Constraint Analysis Checklist: Force 2-minute constraint review before coding
  6. Traversal Type Decision Tree: When to use in-order vs pre-order vs post-order vs level-order
  7. Edge Case Enumeration Template: Standard questions for null/empty/single-element cases

Problem Addition Template (for future problems):

### [Problem Number]. [Problem Name]
**URL**: [LeetCode URL]
**Difficulty**: [Easy/Medium/Hard]
**Primary Category**: [Main algorithmic category]
**Secondary Categories**: [Supporting concepts]
**Pattern**: [High-level problem pattern]

**Errors Made**:
- **[Category]**: [Specific error description]
- **[Category]**: [Specific error description]

**Error Categories**:
- [Meta-category classification]

Questions for Further Investigation

  • How can constraint analysis be systematized?
  • What’s the optimal balance between speed and thoroughness in problem reading?
  • Which API knowledge gaps are most costly in interviews?
  • How do successful problem solvers approach the comprehension phase?

Graph View

Backlinks