数据结构 图 最短路径

（1）从某个源点到其余各顶点的最短路径

Dijkstra的代码如下：

头文件：

#define  INFINITY 10000
#define  MAX_VERTEX_NUM 20

typedef  int  InfoType;
typedef  char  VertexType;
typedef  int  VRType;

typedef  enum   ... {DG, DN, UDG, UDN}  GraphKind;

typedef  struct  ArcCell ... {
    VRType adj;
    InfoType *info;
} ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef  struct ... {
    VertexType vexs[MAX_VERTEX_NUM];
    AdjMatrix arcs;
    int vexnum, arcnum;
    GraphKind kind;
} MGraph;

int  weight[][ 6 ]  =   ... {
    ...{0, INFINITY, 10, INFINITY, 30, 100},
    ...{INFINITY, 0, 5, INFINITY, INFINITY, INFINITY},
    ...{INFINITY, INFINITY, 0, 50, INFINITY, INFINITY},
    ...{INFINITY, INFINITY, INFINITY, 0, INFINITY, 10},
    ...{INFINITY, INFINITY, INFINITY, 20, 0, 60},
    ...{INFINITY, INFINITY, INFINITY, INFINITY, INFINITY, 0}
} ;

// #define INPUT 1

源文件：

#include  " graph_dj.h "
#include  " stdio.h "
#include  " stdlib.h "

void  createDG(MGraph  & g) ... {}
void  createDN(MGraph  & g) ... {}
void  createUDG(MGraph  & g) ... {}

int  locate(MGraph g,  char  name) ... {
    for(int i = 0; i < g.vexnum; i++)...{
        if(name == g.vexs[i])...{
            return i;
        }
    }
    return -1;
}

void  createUDN(MGraph  & g) ... {
    
#ifdef INPUT
    printf("input the number of vertex and arcs: ");
    scanf("%d %d", &g.vexnum, &g.arcnum);
    fflush(stdin);
#else
    printf("input the number of vertex: ");
    scanf("%d", &g.vexnum);
    fflush(stdin);
#endif
    
    int i = 0, j = 0, k = 0;
    
    printf("input the name of vertex: ");

    for(i = 0; i < g.vexnum; i++)...{
        scanf("%c", &g.vexs[i]);
        fflush(stdin);
    }
    
    for(i = 0; i < g.vexnum; i++)...{
        for(j = 0; j < g.vexnum; j++)...{
            g.arcs[i][j].adj = INFINITY;
            g.arcs[i][j].info = NULL;
        }
    }
    
#ifdef INPUT
    char v1, v2;
    int w;
    printf("input the %d arcs v1 v2 and weight: ", g.arcnum);
    for(k = 0; k < g.arcnum; k++)...{
        scanf("%c %c %d", &v1, &v2, &w);
        fflush(stdin);
        i = locate(g, v1);
        j = locate(g, v2);
        g.arcs[i][j].adj = w;
    }
#else
    printf("now constructing the matrix of graph... ");
    for(i = 0; i < g.vexnum; i++)...{
        for(j = 0; j < g.vexnum; j++)...{
            g.arcs[i][j].adj = weight[i][j];
        }
    }
#endif
}

void  printGraph(MGraph g) ... {
    for(int i = 0; i < g.vexnum; i++)...{
        for(int j = 0; j < g.vexnum; j++)...{
            printf("%d ", g.arcs[i][j].adj);
        }
        printf(" ");
    }
}

void  createGragh(MGraph  & g) ... {
    
    printf("please input the type of graph: ");
    scanf("%d", &g.kind);
    
    switch(g.kind)...{
    case DG: 
        createDG(g);
        break;
    case DN: 
        createDN(g);
        break;
    case UDG: 
        createUDG(g);
        break;
    case UDN: 
        createUDN(g);
        printGraph(g);
        break;
    }
}

void  dijkstra(MGraph g) ... {
    int *dist = (int *)malloc(sizeof(int) * g.vexnum);
    int *parent = (int *)malloc(sizeof(int) * g.vexnum);
    int *final = (int *)malloc(sizeof(int) * g.vexnum);

    int i, j, k, cost;
    //init the arrays
    for(i = 0; i < g.vexnum; i++)...{
        dist[i] = g.arcs[0][i].adj;
        parent[i] = 0;
        final[i] = 0;
    }
    //join the start 0.
    final[0] = 1;
    
    for(i = 1; i < g.vexnum; i++)...{
        //get the min of dist
        cost = INFINITY;
        k = -1;
        for(j = 1; j < g.vexnum; j++)...{
            if(dist[j] < cost && final[j] == 0)...{
                cost = dist[j];
                k = j;
            }
        }

        if(k > 0)...{
            //join the k node
            final[k] = 1;

            //update the dist
            for(int t = 1; t < g.vexnum; t++)...{
                if(final[t] == 0)...{
                    if(dist[t] > dist[k] + g.arcs[k][t].adj)...{
                        dist[t] = dist[k] + g.arcs[k][t].adj;
                        parent[t] = k;
                    }
                }
            }
        }
    }

    //print the dist and parent array
    printf("the shortest path from %c is as follows: ", g.vexs[0]);
    for(i = 0; i < g.vexnum; i++)...{
        printf("%c via %c's dist is %d ", 
            g.vexs[i], g.vexs[parent[i]], dist[i]);
    }
}

void  main() ... {
    MGraph g;
    createGragh(g);
    dijkstra(g);
}

程序的执行结果如下：

please input the type of graph:
3
input the number of vertex:
6
input the name of vertex:
a
b
c
d
e
f
now constructing the matrix of graph...
0         10000     10        10000     30        100
10000     0         5         10000     10000     10000
10000     10000     0         50        10000     10000
10000     10000     10000     0         10000     10
10000     10000     10000     20        0         60
10000     10000     10000     10000     10000     0
the shortest path from a  is   as  follows:
a via a ' s dist is 0
b via a ' s dist is 10000
c via a ' s dist is 10
d via e ' s dist is 50
e via a ' s dist is 30
f via d ' s dist is 60
Press any key to  continue

说明：Dijkstra算法的复杂度是O(n * n)。

（2）每一对顶点之间的最短路径

方法一：对每个顶点依次运行Dijkstra，复杂度O(n*n*n)。

方法二：floyd，复杂度O(n*n*n)。

头文件修改：

int  weight[][ 3 ]  =   ... {
    ...{0, 4, 11},
    ...{6, 0, 2},
    ...{3, INFINITY, 0}
} ;

源文件添加：

void  floyd(MGraph g) ... {
    int dist[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int parent[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

    //init the arrays
    int i, j;
    for(i = 0; i < g.vexnum; i++)...{
        for(j = 0; j < g.vexnum; j++)...{
            dist[i][j] = g.arcs[i][j].adj;
            parent[i][j] = i;
        }
    }

    //compute the shortest path
    for(int k = 0; k < g.vexnum; k++)...{
        for(i = 0; i < g.vexnum; i++)...{
            for(j = 0; j < g.vexnum; j++)...{
                if(i != j && i != k && j != k)...{
                    if(dist[i][j] > dist[i][k] + dist[k][j])...{
                        dist[i][j] = dist[i][k] + dist[k][j];
                        parent[i][j] = k;
                    }
                }
            }
        }
    }

    //print the shortest path and parent
    for(i = 0; i < g.vexnum; i++)...{
        for(j = 0; j < g.vexnum; j++)...{
            printf("%d(%c) ", dist[i][j], g.vexs[parent[i][j]]);
        }
        printf(" ");
    }
}

void  main() ... {
    MGraph g;
    createGragh(g);
    dijkstra(g);
    floyd(g);
}

程序的运行结果如下：

please input the type of graph:
3
input the number of vertex:
3
input the name of vertex:
a
b
c
now constructing the matrix of graph...
0         4         11
6         0         2
3         10000     0
the shortest path from a  is   as  follows:
a via a ' s dist is 0
b via a ' s dist is 4
c via b ' s dist is 6
0 (a)     4 (a)     6 (b)
5 (c)     0 (b)     2 (b)
3 (c)     7 (a)     0 (c)
Press any key to  continue