Distance from everywhere to everywhere

Three nested loops and a table. When the network is small and you want every distance, this is the answer.

1. 01
   floyd_warshall fills the entire pair-wise distance table in one call. On the petgraph API it returns a HashMap keyed by (NodeIndex, NodeIndex) — perfect for caching a delivery-zone travel matrix you precompute once and serve from forever.

   use petgraph::algo::floyd_warshall;
   use petgraph::graph::{DiGraph, NodeIndex};
   use std::collections::HashMap;
   
   fn travel_matrix(zones: &DiGraph<&str, u32>)
       -> HashMap<(NodeIndex, NodeIndex), u32>
   {
       floyd_warshall(zones, |e| *e.weight())
           .expect("no negative cycles in travel times")
   }

2. 02
   If NodeIndex has been showing up since page 7 without an introduction, here it is. A NodeIndex is petgraph's handle for a node — a small, cheap-to-copy ID the library hands you when you add a node, which you then pass back to every subsequent operation that needs to refer to that node. It is NOT the node's payload (the &str label, the Customer struct, whatever you stored). Internally, petgraph keeps nodes in a Vec<T> — that's Rust's growable list type (we saw it back in the schedule checker), a contiguous block of values indexed by integers 0, 1, 2, …. When people say "vector" in Rust they mean Vec, not the math-class arrow. NodeIndex is a wrapper around the integer position into that Vec. That's why every graph operation is O(1), why the stored values don't need to be hashable or unique, and why this page can key a HashMap<(NodeIndex, NodeIndex), u32> on node-pair tuples to a distance. Two named nodes can carry identical labels; their NodeIndex handles are still distinct.

   use petgraph::graph::{DiGraph, NodeIndex};
   use std::collections::HashMap;
   
   let mut g = DiGraph::<&str, u32>::new();
   
   // add_node returns the handle for the node you just stored.
   let a: NodeIndex = g.add_node("Alice");    // NodeIndex(0)
   let b: NodeIndex = g.add_node("Bob");      // NodeIndex(1)
   let c: NodeIndex = g.add_node("Carol");    // NodeIndex(2)
   
   // Every subsequent operation takes the handle, never the label.
   g.add_edge(a, b, 5);
   g.add_edge(b, c, 3);
   
   // Look up the stored payload from the handle:
   let name = g[a];                            // → "Alice"
   
   // NodeIndex is Copy + Eq + Hash, so it works as a HashMap key.
   let mut distances: HashMap<NodeIndex, u32> = HashMap::new();
   distances.insert(a, 0);
   distances.insert(b, 5);
   
   
   // Mental model:
   //
   //   internal Vec of node payloads:
   //     index 0  →  "Alice"
   //     index 1  →  "Bob"
   //     index 2  →  "Carol"
   //
   //   NodeIndex(1)  ─is the address of─►  index 1  ←  "Bob"'s payload
   //
   // The label is data the graph happens to be storing at that slot.
   // The NodeIndex is how you refer to the slot.