Floyd-Warshall — All-Pairs Shortest Path

dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])

import math

def floyd_warshall(n, edges):
    dist = [[math.inf]*n for _ in range(n)]
    for i in range(n): dist[i][i] = 0
    for u, v, w in edges:
        dist[u][v] = min(dist[u][v], w)

    for k in range(n):
        for i in range(n):
            for j in range(n):
                if dist[i][k] + dist[k][j] < dist[i][j]:
                    dist[i][j] = dist[i][k] + dist[k][j]
    return dist

function floydWarshall(n, edges) {
    const dist=Array.from({length:n},(_,i)=>Array.from({length:n},(_,j)=>i===j?0:Infinity));
    for(const[u,v,w]of edges)dist[u][v]=Math.min(dist[u][v],w);
    for(let k=0;k<n;k++)for(let i=0;i<n;i++)for(let j=0;j<n;j++)
        if(dist[i][k]+dist[k][j]<dist[i][j])dist[i][j]=dist[i][k]+dist[k][j];
    return dist;
}

public int[][] floydWarshall(int n, int[][] edges) {
    int INF=Integer.MAX_VALUE/2;
    int[][] d=new int[n][n];
    for(int[]r:d)java.util.Arrays.fill(r,INF);
    for(int i=0;i<n;i++)d[i][i]=0;
    for(int[]e:edges)d[e[0]][e[1]]=Math.min(d[e[0]][e[1]],e[2]);
    for(int k=0;k<n;k++)for(int i=0;i<n;i++)for(int j=0;j<n;j++)
        if(d[i][k]<INF&&d[k][j]<INF)d[i][j]=Math.min(d[i][j],d[i][k]+d[k][j]);
    return d;
}

#include <vector>
#include <climits>
using namespace std;
vector<vector<int>> floydWarshall(int n, vector<array<int,3>>& edges){
    const int INF=1e9;
    vector<vector<int>> d(n,vector<int>(n,INF));
    for(int i=0;i<n;i++)d[i][i]=0;
    for(auto&e:edges)d[e[0]][e[1]]=min(d[e[0]][e[1]],e[2]);
    for(int k=0;k<n;k++)for(int i=0;i<n;i++)for(int j=0;j<n;j++)
        if(d[i][k]<INF&&d[k][j]<INF)d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
    return d;
}

#define INF 1000000000
void floydWarshall(int d[][100],int n){
    for(int k=0;k<n;k++)for(int i=0;i<n;i++)for(int j=0;j<n;j++)
        if(d[i][k]<INF&&d[k][j]<INF&&d[i][k]+d[k][j]<d[i][j])d[i][j]=d[i][k]+d[k][j];
}