Dijkstra算法

一 Dijkstra算法

　　Dijkstra算法解决了有向图G=(V, E)上带权的单源最短路径问题，但要求所有边的权值非负。Dijkstra算法采用贪心策略。

　　最短路径的最优子结构：最短路径的子路径是最短路径。
　　从源顶点s出发，可以确认唯一的顶点u1(除非存在顶点v1，其weight(s,v1)=weight(s,u1))，使它的前趋为s，且s->u为最短路径，此时weight(s,u1)在s的各临边中最小。与s相邻的其他顶点，总会通过松弛方法得出最短路径。

　　除了邻接表外还有3个数组，当前最短距离distance，前趋顶点pre，是否已访问过顶点(即已确定好最短路径的顶点)visited。

　　假设单源顶点为srcIdx，则Dijkstra算法步骤如下：

　　① 初始化：distance设置为INT_MAX，pre设置为-1，visited设为false，distance[srcIdx]=0

　　② 循环VertexNum次：每次从distance中取出visited为false，且distance最短的minIdx，此时将visited[minIdx]变为true，并通过松弛的方法确认minIdx的后续各顶点的最短路径上界。每次循环可以确定源顶点srcIdx到某个顶点的最短路径。

　　③ 递归打印源顶点srcIdx到各顶点的最短路径，及最短长度。

核心代码：

void initializeSingleSource(int srcIdx, int VertexNum, int *distance, int *pre, bool *visited)
{
    for (int i=0;i<VertexNum;i++)
    {
        distance[i] = INT_MAX;
        pre[i] = -1;
        visited[i] = false;
    }
    distance[srcIdx] = 0;
}

int extractMin(bool *visited, int *distance)
{// 获取当前距离最短的顶点索引
    int distanceMax = INT_MAX;
    int minIdx = -1;
    for (int j=0;j<VertexNum;j++)
    {
        if (visited[j] == false && distance[j] < distanceMax)
        {
            distanceMax = distance[j];
            minIdx = j;
        }
    }
    return minIdx;
}

void relax(int u, int v, int w, int *d, int *pre)
{
    if (d[v] > d[u] + w)
    {
        d[v] = d[u] + w;
        pre[v] = u;
    }
}

void visitPre(int idx, int *pre, int distance)
{
    if (pre[idx] != -1)
    {
        visitPre(pre[idx], pre, distance);
        cout << "-->" << idx;
    }
    else
        cout << idx << "(" << distance << ")";
}

void printShortestPath(int *pre, int *distance)
{
    cout << "打印最短路径及最短长度：" << endl;
    for (int i=0;i<VertexNum;i++)
    {
        visitPre(i, pre, distance[i]);
        cout << endl;
    }
}

void dijkstra(Vertex *graph, int srcIdx, int VertexNum)
{
    int *distance = new int[VertexNum];
    int *pre = new int[VertexNum];
    bool *visited = new bool[VertexNum];

    initializeSingleSource(srcIdx, VertexNum, distance, pre, visited);

    for (int i=0;i<VertexNum;i++)
    {
        int minIdx = extractMin(visited, distance);
        visited[minIdx] = true;

        Vertex *vertex = &graph[minIdx];
        while (vertex->next)
        {// 访问该顶点的所有后续顶点，确立当前的最短路径
            int vIdx = vertex->next->idx;
            if (visited[vIdx] == false)
                relax(minIdx, vIdx, vertex->next->weight, distance, pre);
            vertex = vertex->next;
        }
    }

    printShortestPath(pre, distance);
}

截图：