dist[i][j] is a table of shortest known distances. The outer loop allows one more node k as a middle stop in each round. The card's invariant says: after the round for k, dist[i][j] is the shortest path from i to j that uses only the nodes 0..k as stops.

Take the shortest path from i to j with stops in 0..k. Either it does not pass through k, or it does. If it does not, it is already in dist[i][j] from the earlier rounds.

If it passes through k, it passes once, because a shortest path does not repeat a node. Cut it at k. The part from i to k and the part from k to j both use only the stops 0..k - 1, so both are already in the table. The test dist[i][k] + dist[k][j] < dist[i][j] finds exactly this case.

Example: in the board below, the direct edge from node 0 to node 2 does not exist. In the round for k = 1, dist[0][1] + dist[1][2] = 3 + 1 = 4 gives dist[0][2] = 4.

The board runs floyd_warshall on the first example of Find the City With the Smallest Number of Neighbors at a Threshold Distance (LC 1334): 4 cities and the roads 0-1:3, 1-2:1, 1-3:4 and 2-3:1. Each road works in both directions, so the board lists each road twice. The threshold is 4.

Round k = 0 changes nothing, because node 0 has only one neighbour. Round k = 1 joins node 0 to nodes 2 and 3 through node 1, so dist[0][2] = 4 and dist[0][3] = 7.

Round k = 2 reads those new values. It sets dist[0][3] = 4 + 1 = 5, and dist[1][3] = 1 + 1 = 2. Round k = 3 changes nothing.

The final table has row 0 as [0, 3, 4, 5]. The number of cities within distance 4 is [2, 3, 3, 2]. Cities 0 and 3 tie at 2, and the problem asks for the larger number, so the answer is 3.

for k in range(n) must be the outermost loop. Round k reads values that the rounds for smaller stops must have finished.

With k innermost, the pair (i, j) is finished before the other pairs have been updated. Example: n = 4 and edges 0 -> 3, 3 -> 2, 2 -> 1, each of cost 1. The right value of dist[0][1] is 3. With i, j, k order, the result is infinity, because dist[0][1] is finished before dist[0][2] has a value.

Two smaller traps. Store a directed edge [u, v] in dist[u][v], not in dist[v][u]. And use min for parallel edges, so a lighter edge that comes first is not lost.

In Java or C++, do not use INT_MAX for no path. INT_MAX + 1 overflows to a negative number. Use INT_MAX / 2, or skip the pair.

Three nested loops over n nodes run n * n * n checks, so the time is O(V^3) and the table takes O(V^2) space. For 4 nodes that is 64 checks. For 100 nodes it is 1000000.

That is fine for a few hundred nodes at most. For a large sparse graph, running Dijkstra from every node (the cheapest-first card) costs about V times O((V + E) log V), which is much less.

If you need distances from only one source, as in Network Delay Time (LC 743), use Dijkstra. If the path may use at most k edges, as in Cheapest Flights Within K Stops (LC 787), use the rounds of Bellman-Ford: this table has no edge count.

If the question is only whether one node can reach another, as in Course Schedule IV (LC 1462), the same loops work with true and false in place of distances. If you need one order in which to take every course, as in Course Schedule II (LC 210), use Topological Sort. That answer is not about pairs.