[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":83,"_73":84,"_35":85},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":62,"_63":64,"_65":66,"_67":68,"_69":70,"_71":72},"id",42,"title","Graph Algorithms in Practice","slug","algorithms-part-15-graph-algorithms-in-practice","excerpt","Apply algorithms to real-world problems: social networks, PageRank implementation, community detection, recommendation systems, and Neo4j patterns.","# Part 15: Graph Algorithms in Practice - Social Networks, PageRank, and Beyond\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Time to Read | 35 minutes |\n| Prerequisites | Parts 11-14 (Graph algorithms) |\n| Key Concepts | Social Networks, PageRank, Community Detection, Recommendations |\n| Difficulty | ⭐⭐⭐ (Intermediate-Advanced) |\n\n```\n┌─────────────────────────────────────────────────────────────────┐\n│ GRAPH ALGORITHMS IN THE REAL WORLD │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ SOCIAL NETWORKS SEARCH & RANKING │\n│ ┌─────────────────┐ ┌─────────────────┐ │\n│ │ U1 ─── U2 │ │ PageRank │ │\n│ │ │ ╲ │ │ │ ┌───┐ │ │\n│ │ │ ╲ │ │ │ →│ A │→ 0.35 │ │\n│ │ U3 ─── U4 │ │ └───┘ │ │\n│ │ │ │ ↓ ↓ │ │\n│ │ Friend-of-friend│ │ ┌───┐ ┌───┐ │ │\n│ │ recommendations │ │ │ B │ │ C │ │ │\n│ └─────────────────┘ │ └───┘ └───┘ │ │\n│ └─────────────────┘ │\n│ │\n│ COMMUNITY DETECTION RECOMMENDATIONS │\n│ ┌─────────────────┐ ┌─────────────────┐ │\n│ │ ┌─────┐ ┌─────┐ │ │ User → Item │ │\n│ │ │ │ │ │ │ │ ↓ ↓ │ │\n│ │ │ A │─│ B │ │ │ Similar users │ │\n│ │ │ │ │ │ │ │ bought this │ │\n│ │ └─────┘ └─────┘ │ │ │ │\n│ │ Clusters │ │ Collaborative │ │\n│ └─────────────────┘ │ filtering │ │\n│ └─────────────────┘ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## 🎯 What You'll Learn\n\nAfter completing this article, you will be able to:\n\n1. **Analyze social networks**: Calculate centrality measures, find influencers\n2. **Implement PageRank**: Understand and code the algorithm behind Google\n3. **Detect communities**: Use modularity-based algorithms\n4. **Build recommendation systems**: Graph-based collaborative filtering\n5. **Use graph databases**: Basic Neo4j patterns\n\n---\n\n## 🔥 Production Story: The Friend Recommendation Engine\n\nA social gaming platform grew to 50 million users. Their friend recommendation system was struggling - suggestions were irrelevant, and user engagement was dropping.\n\n### The Problem\n\n```\n❌ Original system (2018):\n- Simple: \"People who played same game\"\n- Result: Recommending strangers with one common game\n- Click-through rate: 2.1%\n- Friend request acceptance: 0.8%\n```\n\nThe team realized they needed to understand the social graph structure.\n\n### The Investigation\n\n```java\n// ❌ Naive recommendation - ignores graph structure\npublic class NaiveRecommender {\n public List recommend(User user) {\n Set userGames = user.getGamesPlayed();\n\n return allUsers.stream()\n .filter(other -> !user.getFriends().contains(other))\n .filter(other -> hasCommonGame(userGames, other))\n .sorted(Comparator.comparing(other ->\n countCommonGames(userGames, other)))\n .limit(10)\n .collect(Collectors.toList());\n }\n\n // Problem: A whale player with 500 games gets recommended to everyone\n // Problem: No consideration of social proximity\n}\n```\n\n### The Solution\n\nThey implemented a multi-signal graph-based approach:\n\n```java\n// ✅ Graph-based recommendation system\npublic class GraphBasedRecommender {\n private final SocialGraph graph;\n private final Map pageRankScores;\n private final Map communityIds;\n\n public List recommend(User user, int limit) {\n // Signal 1: Friends-of-friends (Jaccard similarity)\n Map fofScores = calculateFoFScores(user);\n\n // Signal 2: Same community membership\n int userCommunity = communityIds.get(user.getId());\n Map communityScores = scoreByCommunit(user, userCommunity);\n\n // Signal 3: Common interests (games, achievements)\n Map interestScores = calculateInterestSimilarity(user);\n\n // Signal 4: Activity level (PageRank as proxy for influence)\n // High PageRank users are more likely to accept/respond\n\n // Combine signals with learned weights\n return combineSignals(user, fofScores, communityScores,\n interestScores, pageRankScores)\n .stream()\n .sorted(Comparator.comparing(\n UserRecommendation::getScore).reversed())\n .limit(limit)\n .collect(Collectors.toList());\n }\n\n private Map calculateFoFScores(User user) {\n Set friends = graph.getFriends(user);\n Map fofCount = new HashMap<>();\n\n for (User friend : friends) {\n for (User fof : graph.getFriends(friend)) {\n if (!fof.equals(user) && !friends.contains(fof)) {\n fofCount.merge(fof, 1, Integer::sum);\n }\n }\n }\n\n // Jaccard-like score: common friends / total potential friends\n Map scores = new HashMap<>();\n for (Map.Entry entry : fofCount.entrySet()) {\n User fof = entry.getKey();\n int common = entry.getValue();\n int total = friends.size() + graph.getFriends(fof).size() - common;\n scores.put(fof, (double) common / total);\n }\n\n return scores;\n }\n}\n```\n\n### The Impact\n\n| Metric | Before | After | Improvement |\n|--------|--------|-------|-------------|\n| Click-through rate | 2.1% | 8.7% | +314% |\n| Friend request acceptance | 0.8% | 4.2% | +425% |\n| Daily active friendships formed | 12K | 89K | +642% |\n| User retention (30-day) | 34% | 47% | +38% |\n\n**Key insight**: Social graph structure reveals relationship potential better than content similarity alone.\n\n---\n\n## 🧠 Mental Model: The Social Graph\n\nThink of a social network as a city with different neighborhoods:\n\n```\n┌─────────────────────────────────────────────────────────────────┐\n│ SOCIAL GRAPH AS A CITY │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ CENTRALITY = IMPORTANCE │\n│ ┌─────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Degree: How many direct connections (popular person) │ │\n│ │ 👤─👤─👤 │ │\n│ │ └─👤 │ │\n│ │ │ │\n│ │ Betweenness: How many paths go through you (broker) │ │\n│ │ 👤──[👤]──👤 (bridge between groups) │ │\n│ │ 👤 👤 │ │\n│ │ │ │\n│ │ Closeness: How quickly you can reach everyone │ │\n│ │ (central location) │ │\n│ │ │ │\n│ │ PageRank: Who points to you matters │ │\n│ │ (endorsed by important people) │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────┘ │\n│ │\n│ COMMUNITIES = NEIGHBORHOODS │\n│ ┌─────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │\n│ │ │ Gaming │──────│ Bridge │──────│ Tech │ │ │\n│ │ │ Friends │ │ Person │ │ Friends │ │ │\n│ │ │ 👤👤👤 │ │ 👤 │ │ 👤👤👤 │ │ │\n│ │ └─────────┘ └─────────┘ └─────────┘ │ │\n│ │ │ │\n│ │ Dense connections within, sparse between │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────┘ │\n│ │\n└────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## 🔬 Deep Dive: Centrality Measures\n\n### Degree Centrality\n\nThe simplest measure - just count connections:\n\n```java\npublic class DegreeCentrality {\n private final Map> adjList;\n\n public DegreeCentrality(int vertices) {\n this.adjList = new HashMap<>();\n for (int i = 0; i < vertices; i++) {\n adjList.put(i, new HashSet<>());\n }\n }\n\n public void addEdge(int u, int v) {\n adjList.get(u).add(v);\n adjList.get(v).add(u); // Undirected\n }\n\n // Raw degree\n public int degree(int vertex) {\n return adjList.get(vertex).size();\n }\n\n // Normalized degree centrality [0, 1]\n public double normalizedDegree(int vertex) {\n int n = adjList.size();\n return (double) degree(vertex) / (n - 1);\n }\n\n // Find top-k by degree\n public List topKByDegree(int k) {\n return adjList.keySet().stream()\n .sorted(Comparator.comparing(this::degree).reversed())\n .limit(k)\n .collect(Collectors.toList());\n }\n}\n```\n\n**Use case**: Finding popular users, identifying hubs.\n\n### Betweenness Centrality\n\nMeasures how often a node appears on shortest paths:\n\n```java\npublic class BetweennessCentrality {\n private final Map> adjList;\n private final int vertices;\n\n public BetweennessCentrality(int vertices) {\n this.vertices = vertices;\n this.adjList = new HashMap<>();\n for (int i = 0; i < vertices; i++) {\n adjList.put(i, new HashSet<>());\n }\n }\n\n public void addEdge(int u, int v) {\n adjList.get(u).add(v);\n adjList.get(v).add(u);\n }\n\n // Brandes' algorithm - O(VE)\n public Map calculate() {\n Map betweenness = new HashMap<>();\n for (int v = 0; v < vertices; v++) {\n betweenness.put(v, 0.0);\n }\n\n for (int s = 0; s < vertices; s++) {\n // Single-source shortest paths\n Deque stack = new ArrayDeque<>();\n Map> predecessors = new HashMap<>();\n Map sigma = new HashMap<>(); // # shortest paths\n Map dist = new HashMap<>();\n\n for (int v = 0; v < vertices; v++) {\n predecessors.put(v, new ArrayList<>());\n sigma.put(v, 0);\n dist.put(v, -1);\n }\n\n sigma.put(s, 1);\n dist.put(s, 0);\n\n Queue queue = new LinkedList<>();\n queue.offer(s);\n\n // BFS\n while (!queue.isEmpty()) {\n int v = queue.poll();\n stack.push(v);\n\n for (int w : adjList.get(v)) {\n // First visit?\n if (dist.get(w) < 0) {\n dist.put(w, dist.get(v) + 1);\n queue.offer(w);\n }\n // Shortest path to w via v?\n if (dist.get(w) == dist.get(v) + 1) {\n sigma.put(w, sigma.get(w) + sigma.get(v));\n predecessors.get(w).add(v);\n }\n }\n }\n\n // Accumulation\n Map delta = new HashMap<>();\n for (int v = 0; v < vertices; v++) {\n delta.put(v, 0.0);\n }\n\n while (!stack.isEmpty()) {\n int w = stack.pop();\n for (int v : predecessors.get(w)) {\n double contribution =\n (double) sigma.get(v) / sigma.get(w) *\n (1 + delta.get(w));\n delta.put(v, delta.get(v) + contribution);\n }\n if (w != s) {\n betweenness.put(w, betweenness.get(w) + delta.get(w));\n }\n }\n }\n\n // Normalize for undirected graph\n for (int v = 0; v < vertices; v++) {\n betweenness.put(v, betweenness.get(v) / 2.0);\n }\n\n return betweenness;\n }\n}\n```\n\n**Visualization**:\n\n```\n┌─────────────────────────────────────────────────────────────────┐\n│ BETWEENNESS CENTRALITY │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ A ─── B ─── C │\n│ │ │ │\n│ D ───[E]─── F E has high betweenness │\n│ │ │ (bridge between left and right) │\n│ G ─── H ─── I │\n│ │\n│ Shortest paths through E: │\n│ A↔F, A↔I, B↔D, B↔G, C↔D, C↔G, etc. │\n│ │\n│ Betweenness(E) = Σ (paths through E / total paths) │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n**Use case**: Finding brokers, identifying bottlenecks, detecting influential spreaders.\n\n### Closeness Centrality\n\nHow close a node is to all others:\n\n```java\npublic class ClosenessCentrality {\n private final Map> adjList;\n private final int vertices;\n\n public double calculate(int vertex) {\n // BFS from vertex to find distances\n int[] dist = bfsDistances(vertex);\n\n // Sum of distances to all reachable vertices\n int totalDist = 0;\n int reachable = 0;\n\n for (int v = 0; v < vertices; v++) {\n if (v != vertex && dist[v] != Integer.MAX_VALUE) {\n totalDist += dist[v];\n reachable++;\n }\n }\n\n if (reachable == 0) return 0.0;\n\n // Closeness = (reachable / n-1) * (reachable / totalDist)\n // This handles disconnected graphs\n double normalization = (double) reachable / (vertices - 1);\n return normalization * reachable / totalDist;\n }\n\n private int[] bfsDistances(int start) {\n int[] dist = new int[vertices];\n Arrays.fill(dist, Integer.MAX_VALUE);\n dist[start] = 0;\n\n Queue queue = new LinkedList<>();\n queue.offer(start);\n\n while (!queue.isEmpty()) {\n int u = queue.poll();\n for (int v : adjList.get(u)) {\n if (dist[v] == Integer.MAX_VALUE) {\n dist[v] = dist[u] + 1;\n queue.offer(v);\n }\n }\n }\n\n return dist;\n }\n}\n```\n\n---\n\n## 🔬 Deep Dive: PageRank Algorithm\n\n### The Intuition\n\nPageRank models a \"random surfer\" browsing the web:\n\n```\n┌─────────────────────────────────────────────────────────────────┐\n│ PAGERANK INTUITION │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ Random Surfer Model: │\n│ 1. Start on a random page │\n│ 2. With probability d (0.85), follow a random link │\n│ 3. With probability (1-d), jump to random page │\n│ 4. PageRank = long-term probability of being on each page │\n│ │\n│ Example: │\n│ ┌─────────────────┐ │\n│ │ │ │\n│ ▼ │ │ \n│ A ────→ B ────→ C │ │\n│ │ │ │ │\n│ │ ▼ │ │\n│ └─────→ D ────────┘ │\n│ │\n│ Page C: Only incoming from B │\n│ Page A: Incoming from C (sole outlink), D │\n│ A likely has higher PageRank than C │\n│ │\n│ Formula: │\n│ PR(A) = (1-d)/N + d × Σ PR(v)/out(v) │\n│ for all v linking to A │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n### Implementation\n\n```java\npublic class PageRank {\n private final int vertices;\n private final List> outLinks;\n private final List> inLinks;\n private final double dampingFactor;\n private final double tolerance;\n private final int maxIterations;\n\n public PageRank(int vertices) {\n this(vertices, 0.85, 1e-6, 100);\n }\n\n public PageRank(int vertices, double dampingFactor,\n double tolerance, int maxIterations) {\n this.vertices = vertices;\n this.dampingFactor = dampingFactor;\n this.tolerance = tolerance;\n this.maxIterations = maxIterations;\n this.outLinks = new ArrayList<>();\n this.inLinks = new ArrayList<>();\n\n for (int i = 0; i < vertices; i++) {\n outLinks.add(new ArrayList<>());\n inLinks.add(new ArrayList<>());\n }\n }\n\n public void addEdge(int from, int to) {\n outLinks.get(from).add(to);\n inLinks.get(to).add(from);\n }\n\n public double[] calculate() {\n double[] rank = new double[vertices];\n double[] newRank = new double[vertices];\n\n // Initialize uniformly\n double initialRank = 1.0 / vertices;\n Arrays.fill(rank, initialRank);\n\n // Handle dangling nodes (no outlinks)\n Set danglingNodes = new HashSet<>();\n for (int v = 0; v < vertices; v++) {\n if (outLinks.get(v).isEmpty()) {\n danglingNodes.add(v);\n }\n }\n\n for (int iter = 0; iter < maxIterations; iter++) {\n // Calculate dangling node contribution\n double danglingSum = 0;\n for (int d : danglingNodes) {\n danglingSum += rank[d];\n }\n double danglingContribution = dampingFactor * danglingSum / vertices;\n\n // Base rank from random jumps\n double baseRank = (1 - dampingFactor) / vertices;\n\n // Calculate new ranks\n double diff = 0;\n for (int v = 0; v < vertices; v++) {\n newRank[v] = baseRank + danglingContribution;\n\n // Add contribution from incoming links\n for (int u : inLinks.get(v)) {\n int outDegree = outLinks.get(u).size();\n newRank[v] += dampingFactor * rank[u] / outDegree;\n }\n\n diff += Math.abs(newRank[v] - rank[v]);\n }\n\n // Swap arrays\n double[] temp = rank;\n rank = newRank;\n newRank = temp;\n\n // Check convergence\n if (diff < tolerance) {\n System.out.println(\"Converged after \" + (iter + 1) + \" iterations\");\n break;\n }\n }\n\n return rank;\n }\n\n // Get top-k pages by PageRank\n public List topK(int k) {\n double[] ranks = calculate();\n\n return IntStream.range(0, vertices)\n .boxed()\n .sorted(Comparator.comparing(i -> -ranks[i]))\n .limit(k)\n .collect(Collectors.toList());\n }\n}\n```\n\n### Matrix Formulation\n\nPageRank can be computed using matrix operations:\n\n```java\npublic class PageRankMatrix {\n public double[] calculate(double[][] adjMatrix, double d) {\n int n = adjMatrix.length;\n\n // Build transition matrix\n double[][] M = new double[n][n];\n for (int j = 0; j < n; j++) {\n double outDegree = 0;\n for (int i = 0; i < n; i++) {\n outDegree += adjMatrix[j][i];\n }\n\n for (int i = 0; i < n; i++) {\n if (outDegree > 0) {\n M[i][j] = adjMatrix[j][i] / outDegree;\n } else {\n // Dangling node - distribute equally\n M[i][j] = 1.0 / n;\n }\n }\n }\n\n // Google matrix: G = d*M + (1-d)*E/n\n // where E is all-ones matrix\n\n // Power iteration\n double[] rank = new double[n];\n Arrays.fill(rank, 1.0 / n);\n\n for (int iter = 0; iter < 100; iter++) {\n double[] newRank = new double[n];\n\n for (int i = 0; i < n; i++) {\n newRank[i] = (1 - d) / n;\n for (int j = 0; j < n; j++) {\n newRank[i] += d * M[i][j] * rank[j];\n }\n }\n\n rank = newRank;\n }\n\n return rank;\n }\n}\n```\n\n### Personalized PageRank\n\nFor recommendations, bias the random jump toward specific nodes:\n\n```java\npublic class PersonalizedPageRank {\n // Instead of jumping to random page, jump to pages in \"seed set\"\n public double[] calculate(int[] seedNodes, double dampingFactor) {\n double[] rank = new double[vertices];\n double[] personalVector = new double[vertices];\n\n // Personal vector: uniform over seed nodes\n for (int seed : seedNodes) {\n personalVector[seed] = 1.0 / seedNodes.length;\n }\n\n Arrays.fill(rank, 1.0 / vertices);\n\n for (int iter = 0; iter < maxIterations; iter++) {\n double[] newRank = new double[vertices];\n\n // Random jump goes to personal vector, not uniform\n for (int v = 0; v < vertices; v++) {\n newRank[v] = (1 - dampingFactor) * personalVector[v];\n }\n\n // Link contribution\n for (int v = 0; v < vertices; v++) {\n for (int u : inLinks.get(v)) {\n int outDegree = outLinks.get(u).size();\n newRank[v] += dampingFactor * rank[u] / outDegree;\n }\n }\n\n rank = newRank;\n }\n\n return rank;\n }\n}\n```\n\n**Use case**: \"Find pages similar to my favorites\" - seed with user's liked pages.\n\n---\n\n## 🔬 Deep Dive: Community Detection\n\n### Modularity\n\nModularity measures the quality of a community partition:\n\n```\n┌─────────────────────────────────────────────────────────────────┐\n│ MODULARITY CONCEPT │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ Q = (1/2m) × Σ [A_ij - (k_i × k_j)/(2m)] × δ(c_i, c_j) │\n│ │\n│ Where: │\n│ - A_ij: adjacency matrix (1 if edge exists) │\n│ - k_i: degree of node i │\n│ - m: total number of edges │\n│ - c_i: community of node i │\n│ - δ: 1 if same community, 0 otherwise │\n│ │\n│ Intuition: Q > 0 means more edges within communities │\n│ than expected by random chance │\n│ │\n│ Good partition: Q ≈ 0.3 to 0.7 │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n### Louvain Algorithm\n\nFast and effective community detection:\n\n```java\npublic class LouvainCommunityDetection {\n private final int vertices;\n private final Map> graph; // weighted\n private int[] community;\n private double[] communityWeight;\n private double totalWeight;\n\n public LouvainCommunityDetection(int vertices) {\n this.vertices = vertices;\n this.graph = new HashMap<>();\n for (int i = 0; i < vertices; i++) {\n graph.put(i, new HashMap<>());\n }\n }\n\n public void addEdge(int u, int v, double weight) {\n graph.get(u).merge(v, weight, Double::sum);\n graph.get(v).merge(u, weight, Double::sum);\n totalWeight += weight;\n }\n\n public int[] detectCommunities() {\n // Initialize: each node in its own community\n community = new int[vertices];\n communityWeight = new double[vertices];\n\n for (int v = 0; v < vertices; v++) {\n community[v] = v;\n communityWeight[v] = nodeWeight(v);\n }\n\n boolean improved = true;\n while (improved) {\n improved = false;\n\n // Phase 1: Local moving\n for (int v = 0; v < vertices; v++) {\n int bestCommunity = community[v];\n double bestGain = 0;\n\n // Try moving v to each neighbor's community\n int currentCommunity = community[v];\n\n // Remove v from its community temporarily\n communityWeight[currentCommunity] -= nodeWeight(v);\n\n for (int neighbor : graph.get(v).keySet()) {\n int neighborCommunity = community[neighbor];\n if (neighborCommunity != currentCommunity) {\n double gain = modularityGain(v, neighborCommunity);\n if (gain > bestGain) {\n bestGain = gain;\n bestCommunity = neighborCommunity;\n }\n }\n }\n\n // Move to best community\n if (bestCommunity != currentCommunity) {\n community[v] = bestCommunity;\n communityWeight[bestCommunity] += nodeWeight(v);\n improved = true;\n } else {\n communityWeight[currentCommunity] += nodeWeight(v);\n }\n }\n }\n\n // Renumber communities to be contiguous\n return renumberCommunities();\n }\n\n private double nodeWeight(int v) {\n return graph.get(v).values().stream()\n .mapToDouble(Double::doubleValue).sum();\n }\n\n private double edgesToCommunity(int v, int targetCommunity) {\n double sum = 0;\n for (Map.Entry edge : graph.get(v).entrySet()) {\n if (community[edge.getKey()] == targetCommunity) {\n sum += edge.getValue();\n }\n }\n return sum;\n }\n\n private double modularityGain(int v, int targetCommunity) {\n double ki = nodeWeight(v);\n double sumIn = edgesToCommunity(v, targetCommunity);\n double sumTot = communityWeight[targetCommunity];\n\n // ΔQ = [sumIn - sumTot×ki/(2m)] / m\n return (sumIn - sumTot * ki / (2 * totalWeight)) / totalWeight;\n }\n\n private int[] renumberCommunities() {\n Map mapping = new HashMap<>();\n int nextId = 0;\n\n int[] result = new int[vertices];\n for (int v = 0; v < vertices; v++) {\n int comm = community[v];\n if (!mapping.containsKey(comm)) {\n mapping.put(comm, nextId++);\n }\n result[v] = mapping.get(comm);\n }\n\n return result;\n }\n\n public double modularity() {\n double q = 0;\n for (int u = 0; u < vertices; u++) {\n for (Map.Entry edge : graph.get(u).entrySet()) {\n int v = edge.getKey();\n if (community[u] == community[v]) {\n double expected = nodeWeight(u) * nodeWeight(v)\n / (2 * totalWeight);\n q += edge.getValue() - expected;\n }\n }\n }\n return q / (2 * totalWeight);\n }\n}\n```\n\n### Label Propagation\n\nSimpler algorithm, often faster:\n\n```java\npublic class LabelPropagation {\n private final int vertices;\n private final Map> adjList;\n private int[] labels;\n\n public LabelPropagation(int vertices) {\n this.vertices = vertices;\n this.adjList = new HashMap<>();\n for (int i = 0; i < vertices; i++) {\n adjList.put(i, new HashSet<>());\n }\n }\n\n public void addEdge(int u, int v) {\n adjList.get(u).add(v);\n adjList.get(v).add(u);\n }\n\n public int[] detectCommunities() {\n // Initialize: each node has unique label\n labels = new int[vertices];\n for (int v = 0; v < vertices; v++) {\n labels[v] = v;\n }\n\n // Create random order for updates\n List order = IntStream.range(0, vertices)\n .boxed().collect(Collectors.toList());\n Random random = new Random(42);\n\n boolean changed = true;\n int iterations = 0;\n int maxIterations = 100;\n\n while (changed && iterations < maxIterations) {\n changed = false;\n Collections.shuffle(order, random);\n\n for (int v : order) {\n // Find most frequent label among neighbors\n Map labelCounts = new HashMap<>();\n\n for (int neighbor : adjList.get(v)) {\n labelCounts.merge(labels[neighbor], 1, Integer::sum);\n }\n\n if (!labelCounts.isEmpty()) {\n // Find label with maximum count\n int maxCount = Collections.max(labelCounts.values());\n List candidates = labelCounts.entrySet().stream()\n .filter(e -> e.getValue() == maxCount)\n .map(Map.Entry::getKey)\n .collect(Collectors.toList());\n\n // Break ties randomly\n int newLabel = candidates.get(\n random.nextInt(candidates.size()));\n\n if (newLabel != labels[v]) {\n labels[v] = newLabel;\n changed = true;\n }\n }\n }\n iterations++;\n }\n\n return renumberLabels();\n }\n\n private int[] renumberLabels() {\n Map mapping = new HashMap<>();\n int[] result = new int[vertices];\n int nextId = 0;\n\n for (int v = 0; v < vertices; v++) {\n int label = labels[v];\n if (!mapping.containsKey(label)) {\n mapping.put(label, nextId++);\n }\n result[v] = mapping.get(label);\n }\n\n return result;\n }\n}\n```\n\n---\n\n## 🔬 Deep Dive: Graph-Based Recommendations\n\n### Collaborative Filtering with Graphs\n\n```java\npublic class GraphCollaborativeFiltering {\n // Bipartite graph: Users ─── Items\n private final Map> userItems; // user → items\n private final Map> itemUsers; // item → users\n\n public GraphCollaborativeFiltering() {\n this.userItems = new HashMap<>();\n this.itemUsers = new HashMap<>();\n }\n\n public void addInteraction(int userId, int itemId) {\n userItems.computeIfAbsent(userId, k -> new HashSet<>()).add(itemId);\n itemUsers.computeIfAbsent(itemId, k -> new HashSet<>()).add(userId);\n }\n\n // User-based: Find similar users, recommend their items\n public List recommendUserBased(int userId, int limit) {\n Set myItems = userItems.getOrDefault(userId, new HashSet<>());\n\n // Find users with similar tastes (Jaccard similarity)\n Map userSimilarity = new HashMap<>();\n\n for (int item : myItems) {\n for (int otherUser : itemUsers.get(item)) {\n if (otherUser != userId) {\n userSimilarity.merge(otherUser, 1.0, Double::sum);\n }\n }\n }\n\n // Normalize by Jaccard\n for (Map.Entry entry : userSimilarity.entrySet()) {\n int otherUser = entry.getKey();\n Set otherItems = userItems.get(otherUser);\n int intersection = entry.getValue().intValue();\n int union = myItems.size() + otherItems.size() - intersection;\n entry.setValue((double) intersection / union);\n }\n\n // Collect items from similar users, weighted by similarity\n Map itemScores = new HashMap<>();\n\n for (Map.Entry user : userSimilarity.entrySet()) {\n double similarity = user.getValue();\n for (int item : userItems.get(user.getKey())) {\n if (!myItems.contains(item)) {\n itemScores.merge(item, similarity, Double::sum);\n }\n }\n }\n\n return itemScores.entrySet().stream()\n .sorted(Map.Entry.comparingByValue().reversed())\n .limit(limit)\n .map(Map.Entry::getKey)\n .collect(Collectors.toList());\n }\n\n // Item-based: Find similar items to user's history\n public List recommendItemBased(int userId, int limit) {\n Set myItems = userItems.getOrDefault(userId, new HashSet<>());\n\n Map itemScores = new HashMap<>();\n\n for (int myItem : myItems) {\n Set usersWhoLikedMyItem = itemUsers.get(myItem);\n\n // Find co-occurring items\n Map coOccurrence = new HashMap<>();\n for (int user : usersWhoLikedMyItem) {\n for (int otherItem : userItems.get(user)) {\n if (!myItems.contains(otherItem)) {\n coOccurrence.merge(otherItem, 1, Integer::sum);\n }\n }\n }\n\n // Score by Jaccard similarity\n for (Map.Entry entry : coOccurrence.entrySet()) {\n int otherItem = entry.getKey();\n int intersection = entry.getValue();\n int union = usersWhoLikedMyItem.size() +\n itemUsers.get(otherItem).size() - intersection;\n double similarity = (double) intersection / union;\n itemScores.merge(otherItem, similarity, Double::sum);\n }\n }\n\n return itemScores.entrySet().stream()\n .sorted(Map.Entry.comparingByValue().reversed())\n .limit(limit)\n .map(Map.Entry::getKey)\n .collect(Collectors.toList());\n }\n}\n```\n\n### Random Walk Recommendations\n\n```java\npublic class RandomWalkRecommender {\n private final Map> userItems;\n private final Map> itemUsers;\n private final Random random = new Random(42);\n\n public List recommendWithRandomWalks(int userId, int numWalks,\n int walkLength, int limit) {\n Set myItems = userItems.getOrDefault(userId, new HashSet<>());\n Map itemVisits = new HashMap<>();\n\n for (int walk = 0; walk < numWalks; walk++) {\n // Start from user\n Object current = userId;\n boolean isUser = true;\n\n for (int step = 0; step < walkLength; step++) {\n if (isUser) {\n // User → random item they interacted with\n int user = (Integer) current;\n Set items = userItems.get(user);\n if (items.isEmpty()) break;\n current = randomElement(items);\n isUser = false;\n } else {\n // Item → random user who interacted\n int item = (Integer) current;\n Set users = itemUsers.get(item);\n if (users.isEmpty()) break;\n current = randomElement(users);\n isUser = true;\n }\n\n // Count visits to items not in user's history\n if (!isUser) {\n int item = (Integer) current;\n if (!myItems.contains(item)) {\n itemVisits.merge(item, 1, Integer::sum);\n }\n }\n }\n }\n\n return itemVisits.entrySet().stream()\n .sorted(Map.Entry.comparingByValue().reversed())\n .limit(limit)\n .map(Map.Entry::getKey)\n .collect(Collectors.toList());\n }\n\n private T randomElement(Set set) {\n int index = random.nextInt(set.size());\n Iterator iter = set.iterator();\n for (int i = 0; i < index; i++) iter.next();\n return iter.next();\n }\n}\n```\n\n---\n\n## 🔬 Deep Dive: Graph Databases (Neo4j Patterns)\n\n### Basic Cypher Queries\n\n```cypher\n// Create nodes and relationships\nCREATE (alice:Person {name: 'Alice', age: 30})\nCREATE (bob:Person {name: 'Bob', age: 25})\nCREATE (alice)-[:KNOWS {since: 2020}]->(bob)\n\n// Find friends of friends\nMATCH (me:Person {name: 'Alice'})-[:KNOWS]->(friend)-[:KNOWS]->(fof)\nWHERE fof <> me AND NOT (me)-[:KNOWS]->(fof)\nRETURN fof.name AS recommendation, COUNT(*) AS mutual_friends\nORDER BY mutual_friends DESC\nLIMIT 10\n\n// PageRank (built-in algorithm)\nCALL gds.pageRank.stream('social-graph')\nYIELD nodeId, score\nRETURN gds.util.asNode(nodeId).name AS name, score\nORDER BY score DESC\nLIMIT 10\n\n// Community detection\nCALL gds.louvain.stream('social-graph')\nYIELD nodeId, communityId\nRETURN communityId, collect(gds.util.asNode(nodeId).name) AS members\nORDER BY size(members) DESC\n\n// Shortest path\nMATCH path = shortestPath(\n (alice:Person {name: 'Alice'})-[:KNOWS*]-(bob:Person {name: 'Bob'})\n)\nRETURN path\n```\n\n### Java Integration with Neo4j\n\n```java\npublic class Neo4jGraphService {\n private final Driver driver;\n\n public Neo4jGraphService(String uri, String user, String password) {\n this.driver = GraphDatabase.driver(uri,\n AuthTokens.basic(user, password));\n }\n\n public List findFriendsOfFriends(String userName) {\n try (Session session = driver.session()) {\n return session.readTransaction(tx -> {\n Result result = tx.run(\n \"MATCH (me:Person {name: $name})-[:KNOWS]->(friend)\" +\n \"-[:KNOWS]->(fof) \" +\n \"WHERE fof <> me AND NOT (me)-[:KNOWS]->(fof) \" +\n \"RETURN DISTINCT fof.name AS name \" +\n \"ORDER BY name\",\n Map.of(\"name\", userName)\n );\n\n List recommendations = new ArrayList<>();\n while (result.hasNext()) {\n recommendations.add(result.next().get(\"name\").asString());\n }\n return recommendations;\n });\n }\n }\n\n public int shortestPathLength(String from, String to) {\n try (Session session = driver.session()) {\n return session.readTransaction(tx -> {\n Result result = tx.run(\n \"MATCH path = shortestPath(\" +\n \"(a:Person {name: $from})-[:KNOWS*]-(b:Person {name: $to})) \" +\n \"RETURN length(path) AS distance\",\n Map.of(\"from\", from, \"to\", to)\n );\n\n if (result.hasNext()) {\n return result.next().get(\"distance\").asInt();\n }\n return -1; // No path\n });\n }\n }\n\n public void close() {\n driver.close();\n }\n}\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: PageRank Dangling Nodes\n\n```java\n// ❌ WRONG: Ignoring dangling nodes (nodes with no outlinks)\nfor (int v : inLinks.get(page)) {\n newRank[page] += damping * rank[v] / outLinks.get(v).size();\n}\n\n// ✅ CORRECT: Distribute dangling node rank\ndouble danglingSum = 0;\nfor (int d : danglingNodes) {\n danglingSum += rank[d];\n}\ndouble danglingContribution = damping * danglingSum / n;\n\nfor (int page = 0; page < n; page++) {\n newRank[page] = (1-damping)/n + danglingContribution;\n // ... add link contributions\n}\n```\n\n---\n\n### Mistake 2: Community Detection Convergence\n\n```java\n// ❌ WRONG: No convergence check\nwhile (true) { // Infinite loop risk\n // Update communities\n}\n\n// ✅ CORRECT: Track changes and limit iterations\nboolean changed = true;\nint iterations = 0;\nint maxIterations = 100;\n\nwhile (changed && iterations < maxIterations) {\n changed = false;\n // Update communities, set changed=true if any change\n iterations++;\n}\n```\n\n---\n\n### Mistake 3: Jaccard Similarity Division by Zero\n\n```java\n// ❌ WRONG: No check for empty intersection\ndouble jaccard = intersection.size() / union.size(); // Division by zero!\n\n// ✅ CORRECT: Handle edge cases\ndouble jaccard = union.isEmpty() ? 0.0 :\n (double) intersection.size() / union.size();\n```\n\n---\n\n## 🐛 Debug This: PageRank Convergence Issue\n\nThis PageRank implementation doesn't converge properly. Can you find the bug?\n\n```java\npublic class BuggyPageRank {\n private int vertices;\n private List> outLinks;\n private List> inLinks;\n\n public double[] calculate(double damping) {\n double[] rank = new double[vertices];\n double[] newRank = new double[vertices];\n\n // Initialize\n Arrays.fill(rank, 1.0 / vertices);\n\n for (int iter = 0; iter < 100; iter++) {\n Arrays.fill(newRank, (1 - damping) / vertices);\n\n for (int v = 0; v < vertices; v++) {\n for (int u : inLinks.get(v)) {\n // BUG IS IN THIS LINE\n newRank[v] += damping * rank[v] / outLinks.get(u).size();\n }\n }\n\n // Check convergence\n double diff = 0;\n for (int v = 0; v < vertices; v++) {\n diff += Math.abs(newRank[v] - rank[v]);\n }\n\n // Swap\n double[] temp = rank;\n rank = newRank;\n newRank = temp;\n\n if (diff < 1e-6) break;\n }\n\n return rank;\n }\n}\n```\n\n

🔍 Click to reveal the bug

\n\n**Bug**: Using `rank[v]` instead of `rank[u]` in the contribution calculation.\n\n```java\n// ❌ BUG: Using rank of target instead of source\nnewRank[v] += damping * rank[v] / outLinks.get(u).size();\n\n// ✅ FIX: Use rank of source node u\nnewRank[v] += damping * rank[u] / outLinks.get(u).size();\n```\n\n**Why this matters**:\n\nPageRank formula: `PR(v) = (1-d)/n + d × Σ PR(u)/out(u)` for all u linking to v\n\nThe contribution to v comes from u's rank, not v's own rank. Using `rank[v]` makes the update self-referential and prevents proper propagation of rank through the graph.\n\n**The symptom**: Ranks don't stabilize properly, or all nodes end up with nearly equal rank regardless of graph structure.\n\n

\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Influence Maximization ⭐⭐\n\nFind k nodes that, if they adopt a product, maximize spread through the network (greedy approximation).\n\n```java\npublic class InfluenceMaximization {\n public List findInfluencers(int k) {\n // Greedy: repeatedly add node that maximizes marginal gain\n // Use Monte Carlo simulation to estimate spread\n }\n}\n```\n\n---\n\n### Exercise 2: Link Prediction ⭐⭐\n\nPredict which edges are likely to form in a social network.\n\n```java\npublic class LinkPredictor {\n public List predictLinks(int limit) {\n // Use features:\n // - Common neighbors\n // - Jaccard coefficient\n // - Adamic-Adar index\n // - Preferential attachment\n }\n}\n```\n\n---\n\n### Exercise 3: Community Evolution ⭐⭐⭐\n\nTrack how communities change over time given snapshots of the network.\n\n```java\npublic class CommunityEvolution {\n public void trackEvolution(List snapshots) {\n // Detect communities in each snapshot\n // Match communities across snapshots\n // Identify: birth, death, merge, split, growth, shrink\n }\n}\n```\n\n---\n\n### Exercise 4: Personalized Recommendations ⭐⭐⭐\n\nImplement Personalized PageRank for item recommendations.\n\n```java\npublic class PersonalizedRecommender {\n // User-item bipartite graph\n public List recommendItems(int userId, int limit) {\n // Run PPR with user as teleport target\n // Return top items by PPR score\n }\n}\n```\n\n---\n\n### Exercise 5: Network Robustness ⭐⭐⭐⭐\n\nAnalyze how the network's connectivity degrades as nodes fail.\n\n```java\npublic class NetworkRobustness {\n public double[] attackSimulation(String strategy) {\n // Strategies: random, degree-based, betweenness-based\n // Return: [fraction removed, largest component size]\n // at each step\n }\n}\n```\n\n---\n\n## 🎤 Interview Questions\n\n### Q1: \"How would you find the most influential person in a social network?\"\n\n**Answer**: It depends on what \"influential\" means:\n\n**Degree centrality** (most connections):\n```java\n// O(1) lookup if you maintain degree counts\nreturn users.stream()\n .max(Comparator.comparing(User::getFriendCount))\n .orElse(null);\n```\n\n**PageRank** (endorsed by important people):\n```java\n// O(E × iterations) - considers quality of connections\ndouble[] pr = pageRank.calculate();\nreturn argmax(pr);\n```\n\n**Betweenness centrality** (controls information flow):\n```java\n// O(VE) - most expensive but finds brokers\nMap bc = betweenness.calculate();\nreturn maxByValue(bc);\n```\n\n**For viral marketing**: Use influence maximization (greedy + Monte Carlo).\n\n---\n\n### Q2: \"Design a 'People You May Know' feature.\"\n\n**Answer**:\n\n```java\npublic class PeopleYouMayKnow {\n public List recommend(User user) {\n Map scores = new HashMap<>();\n\n // Signal 1: Friends of friends (strongest signal)\n for (User friend : user.getFriends()) {\n for (User fof : friend.getFriends()) {\n if (!user.equals(fof) && !user.getFriends().contains(fof)) {\n // Weight by mutual friend count\n scores.merge(fof, 1.0, Double::sum);\n }\n }\n }\n\n // Signal 2: Same workplace/school\n for (User candidate : scores.keySet()) {\n if (sameWorkplace(user, candidate)) scores.merge(candidate, 0.5, Double::sum);\n if (sameSchool(user, candidate)) scores.merge(candidate, 0.3, Double::sum);\n }\n\n // Signal 3: Geographic proximity\n // Signal 4: Interaction patterns (mutual likes, comments)\n\n return scores.entrySet().stream()\n .sorted(Map.Entry.comparingByValue().reversed())\n .limit(20)\n .map(e -> new UserRecommendation(e.getKey(), e.getValue()))\n .collect(Collectors.toList());\n }\n}\n```\n\n**Considerations**:\n- Privacy: Don't reveal why someone is recommended\n- Diversity: Don't recommend only from one circle\n- Freshness: Boost recently active users\n\n---\n\n### Q3: \"Explain how PageRank handles the 'spider trap' problem.\"\n\n**Answer**: A spider trap is a group of pages that link only to each other, which would accumulate all PageRank over time.\n\n```\nSpider trap: Normal web:\nA → B → C A → B → C\n↑ ↓ ↓ ↓ ↓\n└─────┘ external links\n```\n\n**Solution**: The damping factor (typically 0.85):\n\n```\nPR(A) = (1-d)/N + d × Σ PR(v)/out(v)\n ↑ ↑\n Random jump Link following\n (15% chance) (85% chance)\n```\n\nWith probability 15%, the surfer teleports to a random page, escaping the trap. This ensures:\n1. All pages have minimum rank (1-d)/N\n2. Rank flows out of traps through random jumps\n3. Algorithm converges to unique solution\n\n---\n\n### Q4: \"How do you detect fake accounts in a social network?\"\n\n**Answer**: Graph-based features reveal anomalies:\n\n```java\npublic class FakeAccountDetector {\n public double fraudScore(User user) {\n double score = 0;\n\n // 1. Low clustering coefficient (friends don't know each other)\n double cc = clusteringCoefficient(user);\n if (cc < 0.1) score += 0.3;\n\n // 2. Unusual degree distribution\n if (user.getFriendCount() > 1000 && user.getAge() < 7) {\n score += 0.2; // Too many friends too fast\n }\n\n // 3. Connected mainly to other suspicious accounts\n double suspiciousFriendRatio = user.getFriends().stream()\n .filter(f -> f.getSuspicionScore() > 0.5)\n .count() / (double) user.getFriendCount();\n score += suspiciousFriendRatio * 0.3;\n\n // 4. Part of dense cluster with external links\n // (bot networks often form cliques)\n\n return Math.min(1.0, score);\n }\n\n private double clusteringCoefficient(User user) {\n Set friends = user.getFriends();\n if (friends.size() < 2) return 0;\n\n int edges = 0;\n for (User f1 : friends) {\n for (User f2 : friends) {\n if (f1.getFriends().contains(f2)) edges++;\n }\n }\n\n int possibleEdges = friends.size() * (friends.size() - 1);\n return (double) edges / possibleEdges;\n }\n}\n```\n\n---\n\n### Q5: \"How would you implement real-time recommendations at scale?\"\n\n**Answer**:\n\n```\nArchitecture:\n┌─────────────────────────────────────────────────────────────────┐\n│ │\n│ 1. Offline Pipeline (daily/hourly) │\n│ - Compute PageRank, communities │\n│ - Build similarity indices │\n│ - Store in Redis/Cassandra │\n│ │\n│ 2. Near-real-time (minutes) │\n│ - Stream processing (Kafka + Flink) │\n│ - Update user activity vectors │\n│ - Incremental graph updates │\n│ │\n│ 3. Real-time (milliseconds) │\n│ - Pre-computed candidates from Redis │\n│ - Light re-ranking with fresh signals │\n│ - A/B test different algorithms │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n```java\npublic class RealTimeRecommender {\n private final RedisClient redis; // Pre-computed candidates\n private final FeatureStore features; // User/item features\n\n public List recommend(User user, int limit) {\n // 1. Fetch pre-computed candidates (fast)\n List candidates = redis.getTopCandidates(user.getId(), 100);\n\n // 2. Real-time filtering\n candidates = candidates.stream()\n .filter(item -> !user.hasInteracted(item))\n .filter(item -> item.isAvailable())\n .collect(Collectors.toList());\n\n // 3. Light re-ranking with fresh features\n return candidates.stream()\n .map(item -> new ScoredItem(item, scoreWithFreshFeatures(user, item)))\n .sorted(Comparator.comparing(ScoredItem::getScore).reversed())\n .limit(limit)\n .map(ScoredItem::getItem)\n .collect(Collectors.toList());\n }\n}\n```\n\n---\n\n## 📋 Quick Reference\n\n### Algorithm Complexity\n\n| Algorithm | Time | Space | Use Case |\n|-----------|------|-------|----------|\n| Degree Centrality | O(V) | O(1) | Find popular nodes |\n| Betweenness | O(VE) | O(V) | Find brokers |\n| PageRank | O(E×iter) | O(V) | Rank importance |\n| Louvain | O(E×iter) | O(V) | Community detection |\n| Label Propagation | O(E×iter) | O(V) | Fast communities |\n\n### Key Formulas\n\n```\nDegree Centrality: C_D(v) = degree(v) / (n-1)\nCloseness Centrality: C_C(v) = (n-1) / Σ d(v,u)\nBetweenness Centrality: C_B(v) = Σ σ_st(v) / σ_st\nPageRank: PR(v) = (1-d)/n + d × Σ PR(u)/out(u)\nModularity: Q = (1/2m) × Σ [A_ij - k_i×k_j/2m] × δ(c_i,c_j)\nJaccard Similarity: J(A,B) = |A ∩ B| / |A ∪ B|\n```\n\n### Decision Guide\n\n```\nNeed to find important nodes?\n├── Most connected → Degree centrality\n├── Information brokers → Betweenness centrality\n├── Endorsed by important → PageRank\n└── Quick access to all → Closeness centrality\n\nNeed to find groups?\n├── High quality → Louvain (modularity optimization)\n├── Fast, large graphs → Label Propagation\n└── Overlapping communities → BigCLAM, DEMON\n\nNeed recommendations?\n├── User-based → Find similar users\n├── Item-based → Find similar items\n└── Graph-based → Random walks, PPR\n```\n\n---\n\n## 🔗 What's Next?\n\nIn **Part 16: Dynamic Programming Foundations**, we'll explore:\n- Optimal substructure and overlapping subproblems\n- Memoization vs tabulation\n- State definition techniques\n- Classic problems: Fibonacci, climbing stairs\n\n---\n\n## 📅 Review Schedule\n\n| Day | Focus | Time |\n|-----|-------|------|\n| 0 | Full read + exercises | 90 min |\n| 1 | PageRank implementation | 15 min |\n| 3 | Community detection code | 20 min |\n| 7 | Build simple recommender | 25 min |\n| 14 | Debug exercise + centrality | 15 min |\n| 30 | Interview questions | 10 min |\n\n---\n\n**Next**: [Part 16: Dynamic Programming Foundations →](./algorithms-part-16-dynamic-programming-foundations.md)\n\n**Series**: [Algorithms Compendium Index](./algorithms-part-0-series-overview.md)\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:25.231775Z","createdAt","2026-06-10T07:19:25.232708Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",25,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Algorithms","readingTime","seriesId",2,"seriesOrder",15,"author",{"_31":55,"_99":57,"_100":101,"_102":103,"_104":-5,"_105":-5,"_106":-5,"_107":-5,"_108":-5},"category",{"_31":95,"_73":59,"_35":96,"_76":97,"_98":-5},"tags",[79,80,81,82],"series",{"_31":62,"_73":74,"_35":75,"_76":77,"_78":23},"name","Algorithms Compendium: From Theory to Production","algorithms-compendium","description","A comprehensive 23-part series covering all essential algorithms for Java developers. From foundational concepts like complexity analysis and recursion, through sorting (QuickSort, MergeSort, TimSort), searching (binary search, string matching), graph algorithms (DFS, BFS, Dijkstra, MST), dynamic programming, greedy algorithms, backtracking, to probabilistic data structures (Bloom filters, HyperLogLog) and interview patterns. Includes real production stories, mental models, exercises, and 100+ interview questions.","isActive",{"_31":92,"_73":93,"_35":94},{"_31":89,"_73":90,"_35":91},{"_31":86,"_73":87,"_35":88},{"_31":83,"_73":84,"_35":85},180,"Social Networks","social-networks",181,"Pagerank","pagerank",183,"Neo4j","neo4j",182,"Community Detection","community-detection",6,"algorithms","Category for Algorithms","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]