Stockbroker Grapevine(AC) Bellman Ford算法

这道题我用的是Bellman Ford算法，用其他的最短路径算法（Floyd、Dijstra）也可。

#include <iostream>

#include <memory.h>



using namespace std;



int weight[101][101];

int dis[101];

int pi[101];

int minTime = 10000;

//最多有 100 * (100-1) 条边，每个边有两个节点

int edgeStack[100 * (100-1) * 2];

//Index 首字母大写，因为 index 在函数库中另有含义　　　　

int Index = 0;　　　　　　　　　　　　　　  

int vertexNum = 0;

int edgeNum = 0;



void PushEdge(int i, int j)

{

     //注意前后置的 ++ 运算符与 Index 的上限的大小关系，要相应 -2 和 -1

    if (Index <= 100*(100-1)*2-1-1)

    {

        edgeStack[Index++] = j;

        edgeStack[Index++] = i;

    }

}



void PopEdge(int &i, int &j)

{

    if (Index >= 2)

    {

        i = edgeStack[--Index];

        j = edgeStack[--Index];

    }

}



void input()

{

    int p;

    int cost;

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

    {

        int edge;

        cin >> edge;

        edgeNum += edge;

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

        {

            cin >> p >> cost;

            weight[j][p] = cost;

            PushEdge(j, p);

        }

    }

}



const int MAX = 10000;

const int NIL = -1;

void Initialize_Single_Source(int s)

{

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

    {

        dis[i] = MAX;

        pi[i] = NIL;

    }

    dis[s] = 0;

}



void Relax(int u, int v)

{

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

    {

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

        pi[v] = u;

    }

}



bool Bellman_Ford(int s)

{

    Index = edgeNum * 2;　　　　　　　　//在每一次调用 Bellman_Ford 时，要记得将 edgeStack 数组下标归末；

    int u, v;

    Initialize_Single_Source(s);

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

    {

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

        {

            PopEdge(u, v);

            Relax(u, v);

        }

        Index = edgeNum * 2;　　　　　　//这里也是

    }

    for (int i=0; i<edgeNum; i++)　　　　//这个循环对这道题来说不是必要的，但为了理解算法导论的算法，就把负环路检测的代码加上了

    {

        PopEdge(u, v);

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

        {

            return false;

        }

    }

    return true;

}



int SelectMax(int dist[101])

{

    int max = 0;

    for (int i=1; i<=vertexNum; i++)　　　//注意这里是 vertexNum 不是 edgeNum，因为 dis 数组保存的是原点 s 至每个点的当前最短距离

    {　　　　　　　　　　　　　　　　　　 //因为这个问题，程序一度中止；

        if (dist[i] > max)

        {

            max = dist[i];

        }

    }

    return max;

}



int main()

{

    int ss;

    cin >> vertexNum;

    while (vertexNum != 0)

    {

        edgeNum = 0;

        Index = 0;

        memset(weight, 0, sizeof(weight));

        memset(edgeStack, 0, sizeof(edgeStack));

        minTime = 10000;



        input();

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

        {

            Bellman_Ford(s);

            int maxTime = SelectMax(dis);

            if (maxTime < minTime)

            {

                minTime = maxTime;

                ss = s;

            }

        }

        if (minTime != MAX)　　　　　　

        {

            cout << ss << ' ';

            Bellman_Ford(ss);

            cout << minTime << endl;

        }

        else  　　　　　　　　　　　　　　　//不要忘了检测 disjoint（非连通）；

        {

            cout << "disjoint" << endl;

        }

        cin >> vertexNum;

    }

    return 0;

}

　　我用数组保存输入的边，以供 Bellman-Ford 算法使用。也可以在 Bellman-Ford 算法中检查 weight 数组的值是否修改，以确定一对节点是否连通，不过这样的话要多一重循环。考虑到时间复杂度，我选择前一种方法。不过，代码多了一倍，也用了更多的时间。总之，各有利弊。在 PushEdge 和 PopEdge 两个函数上的前后置运算符Index++， --index上用了一些时间，一定要记得，如果 PushEdge 中使用 Index++，PopEdge 就一定要用 --index。（久不写代码，生疏了。）