def floyd_warshall(V, edges):
    # Initialize distance matrix
    dist = [[0 if i == j else float('inf') for j in range(V)] for i in range(V)]

    for u, v, w in edges:
        dist[u][v] = w

    for k in range(V):
        for i in range(V):
            for j in range(V):
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])

    return dist

edges = [
    (0, 1, 2),
    (1, 0, 7),
    (1, 2, 3),
    (2, 1, 8),
    (2, 3, 2),
    (3, 0, 1),
    (3, 1, 5)
]

print(floyd_warshall(4, edges))
    

import java.util.*;

class Solution {

    static int[][] floydWarshall(int V, int[][] edges) {
        int INF = (int) 1e9;
        int[][] dist = new int[V][V];

        // Initialize
        for (int i = 0; i < V; i++) {
            Arrays.fill(dist[i], INF);
            dist[i][i] = 0;
        }

        for (int[] e : edges) {
            dist[e[0]][e[1]] = e[2];
        }

        for (int k = 0; k < V; k++) {
            for (int i = 0; i < V; i++) {
                for (int j = 0; j < V; j++) {
                    if (dist[i][k] < INF && dist[k][j] < INF)
                        dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
                }
            }
        }
        return dist;
    }

    public static void main(String[] args) {
        int[][] edges = {
            {0, 1, 2},
            {1, 0, 7},
            {1, 2, 3},
            {2, 1, 8},
            {2, 3, 2},
            {3, 0, 1},
            {3, 1, 5}
        };

        int[][] res = floydWarshall(4, edges);
        for (int[] row : res)
            System.out.println(Arrays.toString(row));
    }
}
    

#include <bits/stdc++.h>
using namespace std;

vector> floydWarshall(int V, vector>& edges) {
    const int INF = 1e9;
    vector> dist(V, vector(V, INF));

    for (int i = 0; i < V; i++)
        dist[i][i] = 0;

    for (auto &e : edges)
        dist[e[0]][e[1]] = e[2];

    for (int k = 0; k < V; k++)
        for (int i = 0; i < V; i++)
            for (int j = 0; j < V; j++)
                if (dist[i][k] < INF && dist[k][j] < INF)
                    dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);

    return dist;
}

int main() {
    vector> edges = {
        {0,1,2},{1,0,7},{1,2,3},
        {2,1,8},{2,3,2},{3,0,1},{3,1,5}
    };

    auto res = floydWarshall(4, edges);
    for (auto &row : res) {
        for (int x : row) cout << x << " ";
        cout << endl;
    }
}
  

#include <stdio.h>
#include <limits.h>

#define V 4
#define INF 1000000000

int main() {
    int dist[V][V];

    // Initialize
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            dist[i][j] = (i == j) ? 0 : INF;
        }
    }

    int edges[][3] = {
        {0, 1, 2},
        {1, 0, 7},
        {1, 2, 3},
        {2, 1, 8},
        {2, 3, 2},
        {3, 0, 1},
        {3, 1, 5}
    };

    int E = 7;
    for (int i = 0; i < E; i++) {
        dist[edges[i][0]][edges[i][1]] = edges[i][2];
    }

    for (int k = 0; k < V; k++)
        for (int i = 0; i < V; i++)
            for (int j = 0; j < V; j++)
                if (dist[i][k] < INF && dist[k][j] < INF &&
                    dist[i][k] + dist[k][j] < dist[i][j])
                    dist[i][j] = dist[i][k] + dist[k][j];

    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++)
            printf("%d ", dist[i][j]);
        printf("\n");
    }
    return 0;
}

using System;

class Solution {
    static int[,] FloydWarshall(int V, int[,] edges) {
        int INF = 1000000000;
        int[,] dist = new int[V, V];

        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                dist[i, j] = (i == j) ? 0 : INF;
            }
        }

        int E = edges.GetLength(0);
        for (int i = 0; i < E; i++) {
            dist[edges[i, 0], edges[i, 1]] = edges[i, 2];
        }

        for (int k = 0; k < V; k++)
            for (int i = 0; i < V; i++)
                for (int j = 0; j < V; j++)
                    if (dist[i, k] < INF && dist[k, j] < INF)
                        dist[i, j] = Math.Min(dist[i, j], dist[i, k] + dist[k, j]);

        return dist;
    }

    static void Main() {
        int[,] edges = {
            {0,1,2},
            {1,0,7},
            {1,2,3},
            {2,1,8},
            {2,3,2},
            {3,0,1},
            {3,1,5}
        };

        var res = FloydWarshall(4, edges);
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++)
                Console.Write(res[i, j] + " ");
            Console.WriteLine();
        }
    }
}