Stockbroker Grapevine(AC) Dijkstra算法

#include <iostream>

#include <memory.h>

using namespace std;

int weight[101][101], dis[101], pi[101];

int visit[101] = {0};

int minTime = 10000, vertexNum = 0;

void input()

{

    int p = 0, cost = 0;

    for (int j=1; j<=vertexNum; j++)

    {

        cin >> weight[j][0];

        for (int i=1; i<=weight[j][0]; i++)

        {

            cin >> p >> cost;

            weight[j][p] = cost;

        }

    }

}

void Relax(int u, int v)

{

    if (dis[v] > dis[u] + weight[u][v])

    {

        dis[v] = dis[u] + weight[u][v];

        pi[v] = u;

    }

}

void Dijkstra(int s)

{

    for (int i=0; i<=100; i++)

    {

        dis[i] = 10000;

        pi[i] = -1;

        visit[i] = 0;//千万不要忘了在初始化的时候将保存“访问标记”的数组 visit 也清空；

    }

    dis[s] = 0;

    int minimum = 1000;

    int j;

    for (int k=1; k<=vertexNum; k++)

    {

        minimum = 1000;

        for (int i=1; i<=vertexNum; i++)

            if (dis[i] <= minimum && !visit[i])//不要忘了这里有等号，是 ”<=“，而不是 ”<“，因为可能有两个点到源点的距离相同，只能分先后访问，不能只访其一；

            {

                j = i;

                minimum = dis[i];

            }

        visit[j] = 1;

        for (int i=1; i<=100; i++)

            if (weight[j][i] != 10000)

                Relax(j, i);

    }

}



int main()

{

    int ss = 0;

    int maxTime = 0;

    while (cin >> vertexNum, vertexNum)

    {

        ss = 0;

        minTime = 10000;

        memset(visit , 0, sizeof(visit));

        for (int i=0; i<101; i++)

        {

            for (int j=0; j<101; j++)

            {

                weight[i][j] = 10000;

            }

        }

        input();

        for (int s=1; s<=vertexNum; s++)

        {

            Dijkstra(s);

            maxTime = 0;

            for (int i=1; i<=vertexNum; i++)

            {

                if (dis[i] >= maxTime)

                    maxTime = dis[i];

            }

            if (maxTime < minTime)

            {

                minTime = maxTime;

                ss = s;

            }

        }

        if (minTime != 10000)

            cout << ss << ' ' << minTime << endl;

        else

            cout << "disjoint" << endl;

    }

    return 0;

}

　　使用 Dijkstra 算法，效率会比 Bellman Ford 算法高些，但写的算法有问题，直到今天才找到，在代码中作了注释，其他的与前一篇相同。由于没有使用数组来保存边的信息，而是用直接检查邻接矩阵的方法，代码简洁了许多。visit 数组定义为局部数组或许更好，那样的话就不用考虑初始化时清空的问题了。