【作业存档】Dijkstra算法的练习

  1 #include <stdio.h>
#include <stdlib.h>

typedef enum { false, true } bool;
#define INFINITY 1000000
#define MaxVertexNum 10  /* maximum number of vertices */
typedef int Vertex;      /* vertices are numbered from 0 to MaxVertexNum-1 */
typedef int WeightType;

typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;
    int Ne;
    WeightType G[MaxVertexNum][MaxVertexNum];
};
typedef PtrToGNode MGraph;

MGraph ReadG(); /* details omitted */

void ShortestDist(MGraph Graph, int dist[], int count[], Vertex S);

int main()
{
    int dist[MaxVertexNum], count[MaxVertexNum];
    Vertex S, V;
    MGraph G = ReadG();

    scanf("%d", &S);
    ShortestDist(G, dist, count, S);

    for (V = 0; V<G->Nv; V++)
        printf("%d ", dist[V]);
    printf("\n");
    for (V = 0; V<G->Nv; V++)
        printf("%d ", count[V]);
    printf("\n");

    return 0;
}


typedef struct Queue * queue;
struct Queue{
    int VNode;
    queue next;
};

typedef struct Q *q;
struct Q{
    queue header;
    queue tail;
};

void Push(int V, q Q){
    queue tmp;
    tmp = (queue)malloc(sizeof(struct Queue));
    tmp->VNode = V;
    tmp->next = NULL;
    Q->tail->next = tmp;
    Q->tail = tmp;
}

int Pop(q Q){
    int V;
    queue tmp;
    tmp = Q->header->next;
    if (!tmp)
        return -1;
    if (tmp == Q->tail)
        Q->tail = Q->header;

    V = tmp->VNode;
    Q->header->next = tmp->next;

    free(tmp);
    return V;
}


void ShortestDist(MGraph Graph, int dist[], int count[], Vertex S){
    q Q = (q)malloc(sizeof(struct Q));
    bool visit[MaxVertexNum][MaxVertexNum];
    int count2[MaxVertexNum];
    Vertex V, W;
    int i,j,tmpDis = 0,tmpC = 0;

    for (i = 0; i < Graph->Nv; i++) {
        dist[i] = -1;
        count[i] = 0;
        for (j = 0; j < Graph->Nv; j++)
            visit[i][j] = 0;
        count2[i] = 0;
    }
    dist[S] = 0;
    count[S] = 1;
    count2[S] = 0;
    Q->header = (queue)malloc(sizeof(struct Queue));
    Q->header->next = NULL;
    Q->header->VNode = -1;
    Q->tail = Q->header;
    
    Push( S,Q);
    while ((V = Pop(Q)) >= 0){
        for (W = 0; W < Graph->Nv; W++){
            if (Graph->G[V][W] > 0){
                tmpDis = dist[V] + Graph->G[V][W];
                if (dist[W] == -1 || tmpDis < dist[W]){
                    dist[W] = tmpDis;
                    count2[W] = count[W];
                    count[W] = count[V];
                    Push(W, Q);
                    for (j = 0; j < Graph->Nv; j++)
                        visit[W][j] = 0;
                    visit[W][V] = count[V];
                }
                else if (tmpDis == dist[W]){
                    count2[W] = count[W];
                    if (visit[W][V]){
                        count[W] = count[W] + count[V] - visit[W][V];
                    }
                    else
                        count[W] += count[V];
                    
                    visit[W][V] = count[V];
                    Push(W, Q);
                }

            }
        }
    }
}


MGraph ReadG()
{
    int i, j;
    int w, v, x;
    MGraph p;
    p = (PtrToGNode)malloc(sizeof(struct GNode));
    scanf("%d%d", &w, &v);
    p->Nv = w, p->Ne = v;
    for (i = 0; i<p->Nv; i++){
        for (j = 0; j<p->Nv; j++){
            p->G[i][j] = -1;
        }
    }
    for (i = 0; i<p->Ne; i++){
        scanf("%d%d%d", &w, &v, &x);
        p->G[w][v] = x;
    }
    return p;
}

void ShortestDist( MGraph Graph, int dist[], int count[], Vertex S );

用这个函数实现，找到图中每个点到源所有的加权最短路径，记录下总长度（边的权值和）和条数。如果不相连，总长度为-1和条数0

dist记录总长度，count记录找到了几条这样的路径。

 

注：这里使用矩阵来表示图的

【知识点复习】：行代表出发的结点，列代表进入的节点

 

【算法实现】：Dijkstra算法的变形。从源出发，遍历其所有临近的结点，如果现在的dist比记录中的短（或为-1），count数归零后继承前一个结点的count数，改变dist值；如果相等，count += 前一个结点的count数，每改变某一个结点的，就将该结点放到队列中。

 

V1：答案错误，检查了一下有三个错误

Push写的位置不对

for循环中因为之前把i改成了W没改全（……）

一开始忘了吧源的count初始化为1了

 

V2：只有第三个测试点对了，似乎是count出了问题，如果曾经count过的点改变后会重复count

 

V3：改正了count的问题，能够正确输出例子，但是就是不能通过pta（QAQ）而且还用到了很多空间，决定按常规算法orz

 

两次Dijkstra算法的版本

void ShortestDist(MGraph Graph, int dist[], int count[], Vertex S){
    int dist2[MaxVertexNum];
    bool isVisit[MaxVertexNum];
    int i, minDis,V, W, tmpDis;

    for (i = 0; i < Graph->Nv; i++){
        dist[i] = INFINITY;
        dist2[i] = INFINITY;
        count[i] = 0;
        isVisit[i] = false;
    }
    dist[S] = 0;
    dist2[S] = 0;
    count[S] = 1;

    for (i = 0; i<Graph->Nv; i++){
        if (Graph->G[S][i]>0){
            dist[i] = Graph->G[S][i];
        }
    }

    isVisit[S] = true;
    dist[S] = 0;

    while (1){
        V = -1;
        minDis = INFINITY;

        for (i = 0; i < Graph->Nv; i++){
            if (!isVisit[i] && dist[i] < minDis){
                V = i;
                minDis = dist[V];
            }
        }
        if (V == -1) break;
        isVisit[V] = true;

        for (W = 0; W < Graph->Nv; W++){
            tmpDis = dist[V] + Graph->G[V][W];
            if (!isVisit[W]&&Graph->G[V][W] > 0 && tmpDis < dist[W]){
                dist[W] = tmpDis;
            }
        }
    }

    for (i = 0; i < Graph->Nv; i++){
        if (dist[i] == INFINITY) 
            dist[i] = -1;
        isVisit[i] = false;
    }


    isVisit[S] = true;
    count[S] = 1;
    dist2[S] = 0;

    for (i = 0; i<Graph->Nv; i++){
        if (Graph->G[S][i]>0){
            dist2[i] = Graph->G[S][i];
            if (dist2[i] == dist[i]){
                count[i] = 1;  
            }
        }
    }


    while (1){
        V = -1;
        minDis = INFINITY;

        for (i = 0; i < Graph->Nv; i++){
            if (!isVisit[i] && dist2[i] < minDis){
                V = i;
                minDis = dist2[V];
            }
        }
        if (V == -1) break;
        isVisit[V] = true;

        for (W = 0; W < Graph->Nv; W++){
            tmpDis = dist2[V] + Graph->G[V][W];
            if (Graph->G[V][W] > 0 && tmpDis < dist2[W]){
                dist2[W] = tmpDis;
                count[W] = count[V];
            }
            else if (Graph->G[V][W] > 0 && tmpDis == dist2[W]){
                count[W] += count[V];
            }
        }
    }

}