本博客的代碼的思想和圖片參考：好大學慕課浙江大學陳越老師、何欽銘老師的《數據結構》

 多源最短路徑算法

1.使用Dijkstra算法對每個頂點運行一次運算，可以得到每個頂點到最圖所有頂點的最小值，時間復雜度為：T = O( |V| 3 + |E||V|)。該算法對稀疏圖比較好

2.使用Floyd算法，時間復雜度為：T = O( |V| 3 )，該算法對稠密圖比較好

下面介紹Floyd算法

D k [i][j] = 路徑{ i --> { l --> k } --> j }的最小長度

D 0 , D 1 , ..., D |V|-1 [i][j]即給出了i到j的真正最短距離

最初的D -1 是什么?

當D k-1 已經完成,遞推到D k 時:

或者k 屬於最短路徑{ i --> { l --> k } --> j },則D k = D k-1

或者k 屬於最短路徑{ i --> { l --> k } --> j },則該路徑必定由兩

段最短路徑組成: D k [i][j]=D k-1 [i][k]+D k-1 [k][j]

void Floyd()

{ for ( i = 0; i < N; i++ )

for( j = 0; j < N; j++ ) {

D[i][j] = G[i][j];

path[i][j] = -1;

}

for( k = 0; k < N; k++ )

for( i = 0; i < N; i++ )

for( j = 0; j < N; j++ )

if( D[i][k] + D[k][j] < D[i][j] ) {

D[i][j] = D[i][k] + D[k][j];

path[i][j] = k;

}

}

 

 

/*
 * floyd.c
 *
 *  Created on: 2017年5月14日
 *      Author: ygh
 */
#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 100 /*define the max number of the vertex*/
#define INFINITY 65535     /*define double byte no negitive integer max number is 65535*/
#define ERROR -1

typedef int vertex; /*define the data type of the vertex*/
typedef int weightType; /*define the data type of the weight*/
typedef char dataType; /*define the data type of the vertex value*/

/*define the data structure of the Edge*/
typedef struct eNode *ptrToENode;
typedef struct eNode {
    vertex v1, v2; /*two vertex between the edge <v1,v2>*/
    weightType weight; /*the value of the edge's weight */
};
typedef ptrToENode edge;

/*define the data structure of the graph*/
typedef struct gNode *ptrToGNode;
typedef struct gNode {
    int vertex_number; /*the number of the vertex*/
    int edge_nunber; /*the number of the edge*/
    weightType g[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; /*define the adjacent matrix weight of graph*/
    dataType data[MAX_VERTEX_NUM]; /*define the dataType array to store the value of vertex*/
};
typedef ptrToGNode adjacentMatrixGraph; /*a graph show by adjacent matrix*/

/*
 create a graph given the vertex number.
 @param vertexNum The verter number of the graph
 @return a graph with vertex but no any egdgs
 */
adjacentMatrixGraph createGraph(int vertexNum) {
    vertex v, w;
    adjacentMatrixGraph graph;
    graph = (adjacentMatrixGraph) malloc(sizeof(struct gNode));
    graph->vertex_number = vertexNum;
    graph->edge_nunber = 0;
    /*initialize the adjacent matrix*/
    for (v = 0; v < graph->vertex_number; v++) {
        for (w = 0; w < graph->vertex_number; w++) {
            graph->g[v][w] = INFINITY;
        }
    }

    return graph;
}

/*
 insert a edge to graph.We will distinct oriented graph and undirected graph
 @param graph The graph you want to insert edge
 @param e The edge you want to insert the graph
 @param isOriented Whether the graph is oriented graph.If the graph is oriented
 we will set adjacent matrix [n][m]=[m][n]=edge's weight,else we only set
 the adjacent matrix [n][m]=edge's weight
 */
void inserEdge(adjacentMatrixGraph graph, edge e, int isOriented) {
    graph->g[e->v1][e->v2] = e->weight;
    if (!isOriented) {
        graph->g[e->v2][e->v1] = e->weight;
    }
}

/*
 construct a graph according user's input

 @return a graph has been filled good
 */
adjacentMatrixGraph buildGraph(int isOrdered) {
    adjacentMatrixGraph graph;
    edge e;
    vertex i;
    int vertex_num;
    scanf("%d", &vertex_num);
    graph = createGraph(vertex_num);
    scanf("%d", &(graph->edge_nunber));
    if (graph->edge_nunber) {
        e = (edge) malloc(sizeof(struct eNode));
        for (i = 0; i < graph->edge_nunber; i++) {
            scanf("%d %d %d", &e->v1, &e->v2, &e->weight);
            e->v1--;
            e->v2--;
            inserEdge(graph, e, isOrdered);
        }
    }
    return graph;

}

/*
 * Floyd algorithms:
 1.D k [i][j] = 路徑{ i --> { l -->  k } -->  j }的最小長度
 2.D 0 , D 1 , ..., D |V|-1 [i][j]即給出了i到j的真正最短距離
 3.最初的D -1 是什么?
 4.當D k-1 已經完成,遞推到D k 時:
 或者k 屬於最短路徑{ i -->  { l -->  k } --> j },則D k = D k-1
 或者k 屬於最短路徑{ i -->  { l -->  k } -->  j },則該路徑必定由兩
 段最短路徑組成: D k [i][j]=D k1 [i][k]+D k1 [k][j]
 *@param graph A graph store by adjacent matrix
 *@param d A two-dimensional array to store the distance value
 *@param path A two-dimensional array to store the path
 */
int floyd(adjacentMatrixGraph graph, weightType d[][MAX_VERTEX_NUM],
        vertex path[][MAX_VERTEX_NUM]) {
    vertex i, j, k;
    /*
     * Initialize array
     */
    for (i = 0; i < graph->vertex_number; i++) {
        for (j = 0; j < graph->vertex_number; j++) {
            d[i][j] = graph->g[i][j];
            path[i][j] = -1;
        }
    }
    for (k = 0; k < graph->vertex_number; k++) {
        for (i = 0; i < graph->vertex_number; i++) {
            for (j = 0; j < graph->vertex_number; j++) {
                if (d[i][k] + d[k][j] < d[i][j]) {
                    d[i][j] = d[i][k] + d[k][j];
                    /*
                     * Find negative circle
                     */
                    if (i == j && d[i][j] < 0) {
                        return 0;
                    }
                    path[i][j] = k;
                }
            }
        }
    }
    return 1;
}

/*
 * Print the distance matrix
 */
void toStringDistance(int d[MAX_VERTEX_NUM][MAX_VERTEX_NUM], int length) {
    vertex i, j;
    for (i = 0; i < length; i++) {
        printf("%d:", i);
        for (j = 0; j < length; j++) {
            printf("%d ", d[i][j]);
        }
        printf("\n");
    }
}

/*
 * Print the path from source to destination
 * we will recursive method to print the path
 * 1.find the k between source and destination
 * 2.find point between source and k and recursive this method until there no points between them
 * 3.find the point between k and destination and recursive this method until there no points between them
 * @param source The index of the source point
 * @param destination The index of the destination
 * @param path A two-dimensional array to store the path
 */
void toStringPath(int source, int destination, vertex path[][MAX_VERTEX_NUM]) {
    if (destination == -1 || source == -1) {
        return;
    } else {
        toStringPath(source, path[source][destination], path);
        if (path[source][destination] != -1) {
            printf("%d ", path[source][destination]);
        }
        toStringPath(path[source][destination], destination, path);
    }

}

/*
 * A test method
 */
int main() {
    adjacentMatrixGraph graph = buildGraph(1);
    int d[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int path[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int source = 1;
    int destination = 5;
    floyd(graph, d, path);
    printf("toDistance\n");
    toStringDistance(d, graph->vertex_number);
    printf("toPath:");
    printf("%d ", source);
    toStringPath(source, destination, path);
    printf("%d", destination);
    return 0;
}

 

下面是一個練習題：

哈利·波特要考試了，他需要你的幫助。這門課學的是用魔咒將一種動物變成另一種動物的本事。例如將貓變成老鼠的魔咒是haha，將老鼠變成魚的魔咒是hehe等等。反方向變化的魔咒就是簡單地將原來的魔咒倒過來念，例如ahah可以將老鼠變成貓。另外，如果想把貓變成魚，可以通過念一個直接魔咒lalala，也可以將貓變老鼠、老鼠變魚的魔咒連起來念：hahahehe。

現在哈利·波特的手里有一本教材，里面列出了所有的變形魔咒和能變的動物。老師允許他自己帶一只動物去考場，要考察他把這只動物變成任意一只指定動物的本事。於是他來問你：帶什么動物去可以讓最難變的那種動物（即該動物變為哈利·波特自己帶去的動物所需要的魔咒最長）需要的魔咒最短？例如：如果只有貓、鼠、魚，則顯然哈利·波特應該帶鼠去，因為鼠變成另外兩種動物都只需要念4個字符；而如果帶貓去，則至少需要念6個字符才能把貓變成魚；同理，帶魚去也不是最好的選擇。

輸入格式:

輸入說明：輸入第1行給出兩個正整數NNN (≤100\le 100≤100)和MMM，其中NNN是考試涉及的動物總數，MMM是用於直接變形的魔咒條數。為簡單起見，我們將動物按1~NNN編號。隨后MMM行，每行給出了3個正整數，分別是兩種動物的編號、以及它們之間變形需要的魔咒的長度(≤100\le 100≤100)，數字之間用空格分隔。

輸出格式:

輸出哈利·波特應該帶去考場的動物的編號、以及最長的變形魔咒的長度，中間以空格分隔。如果只帶1只動物是不可能完成所有變形要求的，則輸出0。如果有若干只動物都可以備選，則輸出編號最小的那只。

輸入樣例:

6 11
3 4 70
1 2 1
5 4 50
2 6 50
5 6 60
1 3 70
4 6 60
3 6 80
5 1 100
2 4 60
5 2 80

輸出樣例:

4 70

/*
 * harrypot.c
 *
 *  Created on: 2017年5月14日
 *      Author: ygh
 */
#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 100 /*define the max number of the vertex*/
#define INFINITY 65535     /*define double byte no negitive integer max number is 65535*/
#define ERROR -1

typedef int vertex; /*define the data type of the vertex*/
typedef int weightType; /*define the data type of the weight*/
typedef char dataType; /*define the data type of the vertex value*/

/*define the data structure of the Edge*/
typedef struct eNode *ptrToENode;
typedef struct eNode {
    vertex v1, v2; /*two vertex between the edge <v1,v2>*/
    weightType weight; /*the value of the edge's weight */
};
typedef ptrToENode edge;

/*define the data structure of the graph*/
typedef struct gNode *ptrToGNode;
typedef struct gNode {
    int vertex_number; /*the number of the vertex*/
    int edge_nunber; /*the number of the edge*/
    weightType g[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; /*define the adjacent matrix weight of graph*/
    dataType data[MAX_VERTEX_NUM]; /*define the dataType array to store the value of vertex*/
};
typedef ptrToGNode adjacentMatrixGraph; /*a graph show by adjacent matrix*/

/*
 create a graph given the vertex number.
 @param vertexNum The verter number of the graph
 @return a graph with vertex but no any egdgs
 */
adjacentMatrixGraph createGraph(int vertexNum) {
    vertex v, w;
    adjacentMatrixGraph graph;
    graph = (adjacentMatrixGraph) malloc(sizeof(struct gNode));
    graph->vertex_number = vertexNum;
    graph->edge_nunber = 0;
    /*initialize the adjacent matrix*/
    for (v = 0; v < graph->vertex_number; v++) {
        for (w = 0; w < graph->vertex_number; w++) {
            graph->g[v][w] = INFINITY;
        }
    }

    return graph;
}

/*
 insert a edge to graph.We will distinct oriented graph and undirected graph
 @param graph The graph you want to insert edge
 @param e The edge you want to insert the graph
 @param isOriented Whether the graph is oriented graph.If the graph is oriented
 we will set adjacent matrix [n][m]=[m][n]=edge's weight,else we only set
 the adjacent matrix [n][m]=edge's weight
 */
void inserEdge(adjacentMatrixGraph graph, edge e, int isOriented) {
    graph->g[e->v1][e->v2] = e->weight;
    if (!isOriented) {
        graph->g[e->v2][e->v1] = e->weight;
    }
}

/*
 construct a graph according user's input

 @return a graph has been filled good
 */
adjacentMatrixGraph buildGraph(int isOrdered) {
    adjacentMatrixGraph graph;
    edge e;
    vertex i;
    int vertex_num;
    scanf("%d", &vertex_num);
    graph = createGraph(vertex_num);
    scanf("%d", &(graph->edge_nunber));
    if (graph->edge_nunber) {
        e = (edge) malloc(sizeof(struct eNode));
        for (i = 0; i < graph->edge_nunber; i++) {
            scanf("%d %d %d", &e->v1, &e->v2, &e->weight);
            e->v1--;
            e->v2--;
            inserEdge(graph, e, isOrdered);
        }
    }
    return graph;

}

int floyd(adjacentMatrixGraph graph, weightType d[][MAX_VERTEX_NUM],
        vertex path[][MAX_VERTEX_NUM]) {
    vertex i, j, k;
    /*
     * Initialize array
     */
    for (i = 0; i < graph->vertex_number; i++) {
        for (j = 0; j < graph->vertex_number; j++) {
            d[i][j] = graph->g[i][j];
            path[i][j] = -1;
        }
    }
    for (k = 0; k < graph->vertex_number; k++) {
        for (i = 0; i < graph->vertex_number; i++) {
            for (j = 0; j < graph->vertex_number; j++) {
                if (d[i][k] + d[k][j] < d[i][j]) {
                    d[i][j] = d[i][k] + d[k][j];
                    /*
                     * Find negative circle
                     */
                    if (i == j) {
                        d[i][j] = INFINITY;
                    }
                    path[i][j] = k;
                }
            }
        }
    }
    return 1;
}

void toStringDistance(int d[MAX_VERTEX_NUM][MAX_VERTEX_NUM], int length) {
    vertex i, j;
    for (i = 0; i < length; i++) {
        printf("%d:", i);
        for (j = 0; j < length; j++) {
            printf("%d ", d[i][j]);
        }
        printf("\n");
    }
}

/*
 * Algorithms thoughts:
 * choose the max value expect for 65535 then sore a array,then find the
 * minimal value from the array and the index
 */
void selectAnnimal(int d[MAX_VERTEX_NUM][MAX_VERTEX_NUM], int length) {
    vertex i, j;
    int maxValue = -1;
    int minValue = 65535;
    int key = 0;
    int arr[length];
    for (i = 0; i < length; i++) {
        maxValue = -1;
        for (j = 0; j < length; j++) {
            if (d[i][j] > maxValue && i != j) {
                maxValue = d[i][j];
            }
        }
        if (maxValue == INFINITY) {
            printf("0\n");
            return;
        } else {
            arr[i] = maxValue;
        }
    }

    for (i = 0; i < length; i++) {
        if (arr[i] < minValue) {
            key = i;
            minValue = arr[i];
        }
    }

    printf("%d %d", key + 1, minValue);
}

int main() {
    adjacentMatrixGraph graph = buildGraph(0);
    int d[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int path[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    floyd(graph, d, path);
    selectAnnimal(d, graph->vertex_number);
    return 0;
}

測試數據：

6 11
3 4 70
1 2 1
5 4 50
2 6 50
5 6 60
1 3 70
4 6 60
3 6 80
5 1 100
2 4 60
5 2 80

輸出樣例:

4 70