floyd

flyod

1：详解

• 0
• 0
  • 0，此时 【0】【0】 不比【0】【0】 + 【0】【0】 小，所以不变
  • 1，此时【0】【1】 和【0】【0】 和 【0】【1】比较
    • 【0】【1】 = 5 【1】【1】 = 0，不比他小
  • 2，此时【0】【2】 【0】【0】+【0】【2】 ,由于权值没有负数，所以 K = 0 没有意义
• 1
  • 0
    • 0，此时【0】【0】 和 【0】【1】 + 【1】【0】比较，无意义
    • 1，此时【0】【1】 和 【0】【1】 + 【1】【1】 比较，无意义
    • 2，此时【0】【2】 和 【0】【2】 + 【2】【2】比较，无意义
  • 1
    • 0，此时【1】【0】 和【1】【1】 + 【1】【0】 比较，无意义
    • 1，此时【1】【1】 和【1】【1】 + 【1】【1】比较，无意义
    • 2，此时【1】【2】 和【1】【1】 + 【1】【2】 比较，无意义
    • 3，此时【1】【3】 和【1】【1】 + 【1】【3】 比较，无意义
  • 2
    • 0，此时【2】【0】 和 【2】【1】 + 【1】【0】 比较，不比她小，所以不变

#include <bits/stdc++.h>

using namespace std;


// Number of vertices in the graph
#define V 4

/* Define Infinite as a large enough
value.This value will be used for
vertices not connected to each other */
#define INF 99999

// A function to print the solution matrix
void printSolution(int dist[][V]);

// Solves the all-pairs shortest path
// problem using Floyd Warshall algorithm
void floydWarshall(int graph[][V])
{
    /* dist[][] will be the output matrix
    that will finally have the shortest
    distances between every pair of vertices */
    int dist[V][V], i, j, k;

    /* Initialize the solution matrix same
    as input graph matrix. Or we can say
    the initial values of shortest distances
    are based on shortest paths considering
    no intermediate vertex. */
    for (i = 0; i < V; i++)
        for (j = 0; j < V; j++)
            dist[i][j] = graph[i][j];

    /* Add all vertices one by one to
    the set of intermediate vertices.
    ---> Before start of an iteration,
    we have shortest distances between all
    pairs of vertices such that the
    shortest distances consider only the
    vertices in set {0, 1, 2, .. k-1} as
    intermediate vertices.
    ----> After the end of an iteration,
    vertex no. k is added to the set of
    intermediate vertices and the set becomes {0, 1, 2, ..
    k} */
    for (k = 0; k < V; k++) {
        // Pick all vertices as source one by one
        for (i = 0; i < V; i++) {
            // Pick all vertices as destination for the
            // above picked source
            for (j = 0; j < V; j++) {
                // If vertex k is on the shortest path from
                // i to j, then update the value of
                // dist[i][j]
                if (dist[i][j] > (dist[i][k] + dist[k][j])
                    && (dist[k][j] != INF
                        && dist[i][k] != INF))
                    dist[i][j] = dist[i][k] + dist[k][j];
            }
        }
    }

    // Print the shortest distance matrix
    printSolution(dist);
}