Add graph flow and cut cards

Author: rollingstorms

assets/card-tags.json

@@ -312,6 +312,15 @@
     ],
     "title": "Adjacency Matrix"
   },
+  "/cards/graphs/augmenting-path/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "algorithms",
+      "network-flow"
+    ],
+    "title": "Augmenting Path"
+  },
   "/cards/graphs/bellman-ford/": {
     "category": "graphs",
     "tags": [
@@ -373,6 +382,60 @@
     ],
     "title": "Dijkstra's Algorithm"
   },
+  "/cards/graphs/dinic/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "algorithms",
+      "network-flow"
+    ],
+    "title": "Dinic's Algorithm"
+  },
+  "/cards/graphs/edge-cut-vs-vertex-cut/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "graph-theory",
+      "connectivity"
+    ],
+    "title": "Edge Cut vs Vertex Cut"
+  },
+  "/cards/graphs/edmonds-karp/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "algorithms",
+      "network-flow"
+    ],
+    "title": "Edmonds-Karp Algorithm"
+  },
+  "/cards/graphs/flow-network/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "graph-theory",
+      "network-flow"
+    ],
+    "title": "Flow Network"
+  },
+  "/cards/graphs/ford-fulkerson/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "algorithms",
+      "network-flow"
+    ],
+    "title": "Ford-Fulkerson Method"
+  },
+  "/cards/graphs/global-minimum-cut/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "algorithms",
+      "graph-theory"
+    ],
+    "title": "Global Minimum Cut"
+  },
   "/cards/graphs/graph-algorithms/": {
     "category": "graphs",
     "tags": [
@@ -390,6 +453,15 @@
     ],
     "title": "Graph Fourier Transform"
   },
+  "/cards/graphs/karger-min-cut/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "algorithms",
+      "randomized"
+    ],
+    "title": "Karger's Algorithm (Min Cut)"
+  },
   "/cards/graphs/kruskal/": {
     "category": "graphs",
     "tags": [
@@ -416,6 +488,26 @@
     ],
     "title": "Graph Laplacian"
   },
+  "/cards/graphs/max-flow-min-cut-theorem/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "algorithms",
+      "optimization",
+      "network-flow"
+    ],
+    "title": "Max-Flow Min-Cut Theorem"
+  },
+  "/cards/graphs/maximum-flow/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "algorithms",
+      "optimization",
+      "network-flow"
+    ],
+    "title": "Maximum Flow"
+  },
   "/cards/graphs/message-passing/": {
     "category": "graphs",
     "tags": [
@@ -425,6 +517,16 @@
     ],
     "title": "Message Passing (on Graphs)"
   },
+  "/cards/graphs/minimum-cut/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "algorithms",
+      "optimization",
+      "network-flow"
+    ],
+    "title": "Minimum Cut"
+  },
   "/cards/graphs/minimum-spanning-tree/": {
     "category": "graphs",
     "tags": [
@@ -468,6 +570,15 @@
     ],
     "title": "Prim's Algorithm"
   },
+  "/cards/graphs/residual-graph/": {
+    "category": "graphs",
+    "tags": [
+      "graphs",
+      "algorithms",
+      "network-flow"
+    ],
+    "title": "Residual Graph"
+  },
   "/cards/graphs/shortest-path/": {
     "category": "graphs",
     "tags": [

assets/formulas.json

@@ -215,6 +215,12 @@
     "route": "/cards/graphs/adjacency-matrix/",
     "formula_markdown": "\\[\nA_{ij} = \\begin{cases}1,& (i,j)\\in E\\\\0,&\\text{otherwise}\\end{cases}\n\\]"
   },
+  {
+    "title": "Augmenting Path",
+    "category": "Graphs",
+    "route": "/cards/graphs/augmenting-path/",
+    "formula_markdown": "\\[\n\\Delta=\\min_{(u,v)\\in P} c_f(u,v)\n\\]"
+  },
   {
     "title": "Bellman-Ford Algorithm",
     "category": "Graphs",
@@ -257,6 +263,42 @@
     "route": "/cards/graphs/dijkstra/",
     "formula_markdown": "\\[\nd(v) = \\min_{(u,v)\\in E}\\big(d(u)+w(u,v)\\big)\n\\]"
   },
+  {
+    "title": "Dinic's Algorithm",
+    "category": "Graphs",
+    "route": "/cards/graphs/dinic/",
+    "formula_markdown": "\\[\n\\text{Repeat: build level graph via BFS, then send a blocking flow}\n\\]"
+  },
+  {
+    "title": "Edge Cut vs Vertex Cut",
+    "category": "Graphs",
+    "route": "/cards/graphs/edge-cut-vs-vertex-cut/",
+    "formula_markdown": "\\[\n\\lambda(G)=\\min |F| \\text{ over edge cuts }F,\\qquad\n\\kappa(G)=\\min |S| \\text{ over vertex cuts }S\n\\]"
+  },
+  {
+    "title": "Edmonds-Karp Algorithm",
+    "category": "Graphs",
+    "route": "/cards/graphs/edmonds-karp/",
+    "formula_markdown": "\\[\n\\text{Each augmentation uses a BFS shortest path (by edge count) in } G_f\n\\]"
+  },
+  {
+    "title": "Flow Network",
+    "category": "Graphs",
+    "route": "/cards/graphs/flow-network/",
+    "formula_markdown": "\\[\nG=(V,E),\\quad c:E\\to \\mathbb{R}_{\\ge 0},\\quad s,t\\in V\n\\]"
+  },
+  {
+    "title": "Ford-Fulkerson Method",
+    "category": "Graphs",
+    "route": "/cards/graphs/ford-fulkerson/",
+    "formula_markdown": "\\[\nf \\leftarrow f + \\Delta \\text{ along an augmenting path } P,\\quad\n\\Delta=\\min_{e\\in P} c_f(e)\n\\]"
+  },
+  {
+    "title": "Global Minimum Cut",
+    "category": "Graphs",
+    "route": "/cards/graphs/global-minimum-cut/",
+    "formula_markdown": "\\[\n\\lambda(G)=\\min_{\\varnothing\\ne S\\subset V,\\ S\\ne V} \\operatorname{cut}(S,V\\setminus S)\n\\]"
+  },
   {
     "title": "Graph Algorithms (Overview)",
     "category": "Graphs",
@@ -269,6 +311,12 @@
     "route": "/cards/graphs/graph-fourier-transform/",
     "formula_markdown": "\\[\n\\hat{x} = U^\\top x\n\\quad\\text{and}\\quad\nx = U\\hat{x}\n\\]"
   },
+  {
+    "title": "Karger's Algorithm (Min Cut)",
+    "category": "Graphs",
+    "route": "/cards/graphs/karger-min-cut/",
+    "formula_markdown": "\\[\n\\text{Repeat random edge contractions until 2 supernodes remain; return crossing edges}\n\\]"
+  },
   {
     "title": "Kruskal's Algorithm",
     "category": "Graphs",
@@ -287,12 +335,30 @@
     "route": "/cards/graphs/laplacian/",
     "formula_markdown": "\\[\nL = D - A\n\\]"
   },
+  {
+    "title": "Max-Flow Min-Cut Theorem",
+    "category": "Graphs",
+    "route": "/cards/graphs/max-flow-min-cut-theorem/",
+    "formula_markdown": "\\[\n\\max\\{\\text{value of an } s\\text{-}t \\text{ flow}\\}\n=\n\\min\\{\\text{capacity of an } s\\text{-}t \\text{ cut}\\}\n\\]"
+  },
+  {
+    "title": "Maximum Flow",
+    "category": "Graphs",
+    "route": "/cards/graphs/maximum-flow/",
+    "formula_markdown": "\\[\n\\max \\sum_{v} f(s,v)\n\\quad\\text{s.t.}\\quad\n0\\le f(u,v)\\le c(u,v),\\;\n\\sum_u f(u,v)=\\sum_w f(v,w)\\ \\ (v\\ne s,t)\n\\]"
+  },
   {
     "title": "Message Passing (on Graphs)",
     "category": "Graphs",
     "route": "/cards/graphs/message-passing/",
     "formula_markdown": "\\[\nm_v^{(t+1)}=\\mathrm{AGG}\\big(\\{\\,\\phi(h_v^{(t)},h_u^{(t)},e_{uv}) : u\\in \\mathcal{N}(v)\\,\\}\\big)\n\\]\n\n\\[\nh_v^{(t+1)}=\\psi(h_v^{(t)}, m_v^{(t+1)})\n\\]"
   },
+  {
+    "title": "Minimum Cut",
+    "category": "Graphs",
+    "route": "/cards/graphs/minimum-cut/",
+    "formula_markdown": "\\[\n\\operatorname{cut}(S,T)=\\sum_{u\\in S,\\ v\\in T} c(u,v),\\qquad\n(S^*,T^*)=\\arg\\min_{s\\in S,\\ t\\in T}\\operatorname{cut}(S,T)\n\\]"
+  },
   {
     "title": "Minimum Spanning Tree (MST)",
     "category": "Graphs",
@@ -323,6 +389,12 @@
     "route": "/cards/graphs/prim/",
     "formula_markdown": "\\[\n\\text{Grow a tree by repeatedly adding the minimum-weight edge crossing the cut}\n\\]"
   },
+  {
+    "title": "Residual Graph",
+    "category": "Graphs",
+    "route": "/cards/graphs/residual-graph/",
+    "formula_markdown": "\\[\nc_f(u,v)=c(u,v)-f(u,v),\\qquad\nc_f(v,u)=f(u,v)\n\\]"
+  },
   {
     "title": "Shortest Path (Overview)",
     "category": "Graphs",

cards/graphs/augmenting-path.md

@@ -0,0 +1,48 @@
+---
+id: graph.augmenting-path
+title: Augmenting Path
+tags: [graphs, algorithms, network-flow]
+related: [graph.residual-graph, graph.ford-fulkerson, graph.edmonds-karp]
+prereqs: [graph.residual-graph]
+---
+
+# Augmenting Path
+
+<div class="formula" markdown="1">
+## Formula
+\[
+\Delta=\min_{(u,v)\in P} c_f(u,v)
+\]
+
+</div>
+<div class="parameters" markdown="1">
+## Parameters
+- \(P\): \(s\)-to-\(t\) path in the residual graph
+- \(c_f(u,v)\): residual capacity on edge \((u,v)\)
+- \(\Delta\): bottleneck residual capacity on \(P\)
+
+</div>
+## What it means
+An augmenting path is a path from source to sink in the residual graph along which additional flow can be pushed by the bottleneck amount \(\Delta\).
+
+## What it's used for
+- Iterative improvement step in Ford-Fulkerson-style max-flow algorithms.
+- Constructive proof that flow is not yet maximal when such a path exists.
+
+## Key properties
+- Augmenting by \(\Delta\) preserves feasibility.
+- If no augmenting path exists, the current flow is maximum.
+- Path selection strategy affects runtime substantially.
+
+## Common gotchas
+- The path is found in the residual graph, not necessarily the original graph.
+- Some path choices can lead to poor performance in Ford-Fulkerson.
+- Bottleneck is the minimum residual capacity, not the sum.
+
+## Example
+If a residual path has capacities \((5,3,9)\), you can augment by 3 units along that path.
+
+## See also
+- [Residual Graph](../graphs/residual-graph.md)
+- [Ford-Fulkerson Method](../graphs/ford-fulkerson.md)
+- [Edmonds-Karp Algorithm](../graphs/edmonds-karp.md)

cards/graphs/dinic.md

@@ -0,0 +1,48 @@
+---
+id: graph.dinic
+title: Dinic's Algorithm
+tags: [graphs, algorithms, network-flow]
+related: [graph.maximum-flow, graph.edmonds-karp, graph.residual-graph]
+prereqs: [graph.maximum-flow, graph.residual-graph, graph.bfs]
+---
+
+# Dinic's Algorithm
+
+<div class="formula" markdown="1">
+## Formula
+\[
+\text{Repeat: build level graph via BFS, then send a blocking flow}
+\]
+
+</div>
+<div class="parameters" markdown="1">
+## Parameters
+- Level graph: residual edges that advance one BFS layer
+- Blocking flow: flow that saturates every \(s\)-\(t\) path in the level graph
+- \(G_f\): residual graph
+
+</div>
+## What it means
+Dinic accelerates max-flow by batching augmentations within layered residual graphs instead of using only one augmenting path per BFS.
+
+## What it's used for
+- Faster max-flow computation in many practical graph problems.
+- Competitive programming and algorithmic graph toolkits.
+
+## Key properties
+- Uses alternating BFS (levels) and DFS-style blocking-flow searches.
+- Improves over Edmonds-Karp in many settings.
+- Classical runtime bound is \(O(|V|^2|E|)\) in general networks.
+
+## Common gotchas
+- Correct implementation needs current-edge pointers to avoid repeated scans.
+- "Blocking flow" is not necessarily a maximum flow in the level graph.
+- Residual updates must maintain reverse edges consistently.
+
+## Example
+After BFS assigns levels, DFS pushes flow only along level-respecting edges until all \(s\)-\(t\) paths in that level graph are blocked.
+
+## See also
+- [Maximum Flow](../graphs/maximum-flow.md)
+- [Edmonds-Karp Algorithm](../graphs/edmonds-karp.md)
+- [Residual Graph](../graphs/residual-graph.md)