Connected Components and Strongly Connected Components: Tarjan / Kosaraju ACERS Engineering Analysis

Subtitle / Abstract Components are foundational for graph algorithms: undirected graphs ask “are nodes connected,” while directed graphs ask “are nodes mutually reachable.” Following the ACERS template, this article moves from naive methods to Tarjan / Kosaraju, then shows production graph-database use cases with runnable multi-language code. Estimated reading time: 14-18 minutes Tags: Graph Theory, Connected Components, SCC, Tarjan SEO keywords: Connected Components, SCC, Tarjan, Kosaraju, graph database Meta description: From undirected connected components to directed SCCs, with clear Tarjan/Kosaraju mechanics, complexity, and production rollout guidance. Target Audience Learners who need BFS/DFS to become second nature Engineers doing subgraph analysis and partition planning in graph-database systems Intermediate developers who want one unified framework for “undirected CC + directed SCC” Background / Motivation In production, you quickly hit three types of questions: ...

February 9, 2026 · 12 min · map[name:Jeanphilo]

Shortest Path Core Trio: BFS, Dijkstra, and A* ACERS Engineering Breakdown

Subtitle / Abstract Shortest path is not one question. It is an engineering skill set: choose the right algorithm by graph conditions. This ACERS article breaks down BFS (unweighted) / Dijkstra (non-negative weights) / A (heuristic)* and gives optimization templates you actually use in relationship graphs, recommendation paths, and path explanations. Estimated reading time: 14-18 minutes Tags: Graph Theory, shortest path, BFS, Dijkstra, A* SEO keywords: shortest path, BFS, Dijkstra, A*, bidirectional search, multi-source BFS Meta description: Engineering guide to the shortest-path core trio: algorithm boundaries, complexity, runnable code, optimization strategies, and practical scenarios. Target Audience Learners reinforcing graph fundamentals who want reusable engineering templates Backend/algorithm engineers working on social links, recommendation paths, or graph-query explanations Developers who know BFS, Dijkstra, and A* by name but still struggle with robust selection and optimization Background / Motivation Shortest-path problems are common in: ...

February 9, 2026 · 15 min · map[name:Jeanphilo]

BFS / DFS Engineering Primer: k-hop Queries, Subgraph Extraction, and Path Existence ACERS Breakdown

Subtitle / Abstract BFS / DFS are not just about “being able to code them.” You need production-ready behavior, predictable cost, and provable correctness. Following the ACERS structure, this article breaks three common tasks (k-hop query, subgraph extraction, and path existence) into reusable templates: iterative implementation + early stop + visited structure selection. Estimated reading time: 12-16 minutes Tags: Graph, BFS, DFS, k-hop, subgraph extraction SEO keywords: BFS, DFS, k-hop query, subgraph extraction, path existence, visited bitmap, bloom filter Meta description: BFS/DFS for engineering scenarios: iterative implementations to avoid stack overflow, early stop to cut search cost, and visited bitmap/bloom to optimize memory and dedup performance. Target Audience Engineers working on graph databases, risk-control relationship graphs, or call-chain analysis Learners who can write “problem-solution style BFS/DFS” but do not yet have engineering templates Developers who want traversal code that is stable, observable, and extensible Background / Motivation In production systems, BFS/DFS is usually not a one-off offline script. It is part of an online request path: ...

February 9, 2026 · 15 min · map[name:Jeanphilo]

Hot100: Intersection of Two Linked Lists Two-Pointer Switch-Head O(1) Space ACERS Guide

Subtitle / Summary The key is not comparing values, but comparing node identity (same object / same address). This ACERS guide explains the naive hash approach, the length-alignment approach, and the most practical switch-head two-pointer template, with runnable multi-language implementations under the no-modification and no-cycle constraints. Reading time: 10-14 min Tags: Hot100, linked list, two pointers SEO keywords: Intersection of Two Linked Lists, switch heads, O(1) space, LeetCode 160 Meta description: Two pointers walk A then B and B then A, guaranteeing meeting at the intersection or both reaching null within m+n steps, with O(m+n) time and O(1) space. A - Algorithm (Problem and Algorithm) Problem Restatement Given heads headA and headB of two singly linked lists, return the node where they intersect. If they do not intersect, return null. ...

February 9, 2026 · 14 min · map[name:Jeanphilo]

Path Sum III: Prefix Sum + Hash Map Counting Downward Paths (LeetCode 437) ACERS Guide

Subtitle / Summary The constraint “the path can start anywhere, but must go downward” makes root-to-leaf DP insufficient. This ACERS guide explains prefix sums on trees: convert any downward path into a difference of two prefix sums, maintain a frequency hash map during one DFS, and finish in O(n). Reading time: 12–15 min Tags: binary tree, prefix sum, DFS, hash map SEO keywords: Path Sum III, tree prefix sum, prefix-sum hash, LeetCode 437 Meta description: Count downward paths whose sum equals targetSum in O(n) via prefix sum + hash map, with derivation, tradeoffs, and multi-language implementations. A — Algorithm (Problem & Algorithm) Problem Restatement Given the root root of a binary tree and an integer targetSum, return the number of downward paths whose node values sum to targetSum. The path does not need to start at the root or end at a leaf, but it must go downward (parent → child). ...

February 4, 2026 · 15 min · map[name:Jeanphilo]

Hot100: Spiral Matrix (Boundary Shrinking Simulation ACERS Guide)

Subtitle / Summary Spiral traversal looks like “just printing in a fancy order”, but the real difficulty is getting boundaries and invariants right. This ACERS guide gives a reusable boundary-shrinking template and runnable multi-language solutions. Reading time: 12–15 min Tags: Hot100, matrix, simulation, boundary shrinking SEO keywords: Hot100, Spiral Matrix, clockwise traversal, boundary shrinking, LeetCode 54 Meta description: O(mn) spiral order traversal using boundary shrinking, with pitfalls, engineering scenarios, and runnable code. A — Algorithm Problem Restatement Given an m × n matrix matrix, return all elements in clockwise spiral order. ...

February 3, 2026 · 13 min · map[name:Jeanphilo]

CNN, RNN, LSTM, and Transformer: Differences and When to Use Each

Using dependency path length and resource complexity, this article compares CNN, RNN, LSTM, and Transformer, and provides runnable examples plus a selection workflow.

January 26, 2026 · 23 min · map[name:Jeanphilo]

Hot100: Trapping Rain Water (Two Pointers O(n) ACERS Guide)

Subtitle / Summary Trapping Rain Water is the classic boundary-constraint problem. This ACERS guide explains the two-pointer method, key formulas, and runnable multi-language solutions. Reading time: 12–15 min Tags: Hot100, two pointers, array SEO keywords: Trapping Rain Water, two pointers, left right max, O(n), Hot100 Meta description: Two-pointer O(n) trapped water solution with engineering scenarios and multi-language code. A — Algorithm Problem Restatement Given an array of non-negative integers representing bar heights (each width 1), compute how much water can be trapped after raining. ...

January 24, 2026 · 7 min · map[name:Jeanphilo]

Hot100: Maximum Subarray (Kadane O(n) ACERS Guide)

Subtitle / Summary Maximum Subarray is the classic 1D DP / greedy template. This ACERS guide explains Kadane’s idea, engineering use cases, and runnable multi-language solutions. Reading time: 10–12 min Tags: Hot100, dynamic programming, greedy SEO keywords: Maximum Subarray, Kadane, dynamic programming, O(n), Hot100 Meta description: Kadane O(n) maximum subarray sum with engineering scenarios and multi-language code. A — Algorithm Problem Restatement Given an integer array nums, find the contiguous subarray with the largest sum (must contain at least one element) and return the sum. ...

January 23, 2026 · 7 min · map[name:Jeanphilo]

LeetCode 1437: Check If All 1's Are at Least K Apart (ACERS Guide)

Subtitle / Summary A classic event-spacing validation model. This ACERS guide explains the one-pass logic, engineering use cases, and runnable multi-language solutions. Reading time: 10–12 min Tags: array, two pointers, event spacing SEO keywords: LeetCode 1437, event spacing, O(n) Meta description: One-pass validation for minimum spacing between 1s, with engineering use cases and multi-language code. A — Algorithm Problem Restatement Given an integer array nums and integer k, return true if every pair of 1s is at least k apart; otherwise return false. ...

January 22, 2026 · 7 min · map[name:Jeanphilo]