多源最短路径算法

本博客的代码的思想和图片参考：好大学慕课浙江大学陈越老师、何钦铭老师的《数据结构》

 多源最短路径算法

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