BEGIN

 FOR ALL v ∈ V

  d[v][v] ← 0

 FOR ALL (u,v) ∈ E

  d[u][v] ← w(u,v)

 for k from 1 to |V|

  for i from 1 to |V|

   for j from 1 to |V|

    if d[i][j] > d[i][k] + d[k][j]

     d[i][j] ← d[i][k] + d[k][j]

    end if

END

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

#define V 4 // Number of vertices

void floydWarshall(int graph[V][V]) {
    int dist[V][V];

    // Initialize distance matrix
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            dist[i][j] = graph[i][j];
        }
    }

    // Main algorithm
    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] != INT_MAX && dist[k][j] != INT_MAX &&
                    dist[i][j] > dist[i][k] + dist[k][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }

    // Print the shortest distances
    printf("Shortest distances between vertices:\n");
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            if (dist[i][j] == INT_MAX) {
                printf("INF ");
            } else {
                printf("%d ", dist[i][j]);
            }
        }
        printf("\n");
    }
}

int main() {
    int graph[V][V] = {
        {0, 5, INT_MAX, 10},
        {INT_MAX, 0, 3, INT_MAX},
        {INT_MAX, INT_MAX, 0, 1},
        {INT_MAX, INT_MAX, INT_MAX, 0}
    };

    floydWarshall(graph);

    return 0;
}

BEGIN

  d(v[1]) ← 0

  FOR j = 2,..,n DO

    d(v[j]) ← ∞

  FOR i = 1,..,(|V|-1) DO

    FOR ALL (u,v) in E DO

      d(v) ← min(d(v), d(u)+l(u,v))

  FOR ALL (u,v) in E DO

    IF d(v) > d(u) + l(u,v) DO

      Message: "Negative Circle"

END

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

#define MAX_VERTICES 100
#define MAX_EDGES 100

typedef struct {
    int u, v, weight;
} Edge;

int numVertices, numEdges;
int distance[MAX_VERTICES];
Edge edges[MAX_EDGES];

void bellmanFord(int startVertex) {
    distance[startVertex] = 0;

    for (int j = 1; j <= numVertices; j++) {
        if (j != startVertex) {
            distance[j] = INT_MAX;
        }
    }

    for (int i = 1; i <= numVertices - 1; i++) {
        for (int k = 0; k < numEdges; k++) {
            int u = edges[k].u;
            int v = edges[k].v;
            int weight = edges[k].weight;

            if (distance[u] != INT_MAX && distance[u] + weight < distance[v]) {
                distance[v] = distance[u] + weight;
            }
        }
    }

    for (int k = 0; k < numEdges; k++) {
        int u = edges[k].u;
        int v = edges[k].v;
        int weight = edges[k].weight;

        if (distance[u] != INT_MAX && distance[u] + weight < distance[v]) {
            printf("Negative Circle\n");
            return;
        }
    }
}

int main() {
    scanf("%d %d", &numVertices, &numEdges);

    for (int i = 0; i < numEdges; i++) {
        scanf("%d %d %d", &edges[i].u, &edges[i].v, &edges[i].weight);
    }

    int startVertex;
    scanf("%d", &startVertex);

    bellmanFord(startVertex);

    for (int i = 1; i <= numVertices; i++) {
        printf("Vertex %d: Distance = %d\n", i, distance[i]);
    }

    return 0;
}