C++多段图的向后处理算法BGRAPH

余祥宣, 崔国华, 邹海明. 计算机算法基础.3版[M]. 华中科技大学出版社, 2006.
P128 算法6.2
使用的数据结构是反向邻接表
程序的输入是一个名字为input.txt的文件，保存时注意编码格式再VS上运行的话要保存为ANSI编码，如果需要的话我可以上传一份
//测试数据2
//增加4到7权重为7
//增加7到12权重为4

12 22 5
2 1 9
3 1 7
4 1 3
5 1 2
6 2 4
7 2 2
8 2 1
6 3 2
7 3 7
8 4 11
7 4 7
7 5 11
8 5 8
9 6 6
10 6 5
9 7 4
10 7 3
12 7 4
10 8 5
11 8 6
12 9 4
12 10 2
12 11 5

//测试数据2
//增加4到7权重为7

12 22 5
2 1 9
3 1 7
4 1 3
5 1 2
6 2 4
7 2 2
8 2 1
6 3 2
7 3 7
8 4 11
7 4 7
7 5 11
8 5 8
9 6 6
10 6 5
9 7 4
10 7 3
10 8 5
11 8 6
12 9 4
12 10 2
12 11 5

//测试数据1

12 21 5
2 1 9
3 1 7
4 1 3
5 1 2
6 2 4
7 2 2
8 2 1
6 3 2
7 3 7
8 4 11
7 5 11
8 5 8
9 6 6
10 6 5
9 7 4
10 7 3
10 8 5
11 8 6
12 9 4
12 10 2
12 11 5

#include<iostream>
#include<fstream>
using namespace std;

#define MAX 13
#define MAXCOST 0x7fffffff/2  //设为最大值整数加法溢出

int BCOST[MAX];
int COST[MAX][MAX];
int D[MAX];
int P[MAX];

typedef int EdgeWeight;//权值类型
typedef struct EdgeNode
{
    int adjvex; //邻接点  
    EdgeWeight weight; //权值  
    struct EdgeNode* next; //指向下一条边  

}EdgeNode;

typedef int VertexType; //顶点类型  
typedef struct
{
    VertexType data;
    EdgeNode* pFirstEdge; //指示第一条边  
}VertexNode;

typedef VertexNode AdjList[MAX];//邻接表  

typedef struct
{
    AdjList adjList; //邻接表  
    int iVexNum; //顶点个数  
    int iEdgeNum; //边数  
    int iLayer;//段数
}AdjListGraph;

//由顶点值得到顶点索引  
int GetIndexByVertexVal(const AdjListGraph& G, VertexType val)
{
    for (int i = 1; i <= G.iVexNum; ++i)
    {
        if (val == G.adjList[i].data)
            return i;
    }
    return -1;
}
//创建有向图  
void CreateAdjListGraph(AdjListGraph& G)
{
    ifstream in("input.txt");
    in >> G.iVexNum >> G.iEdgeNum>>G.iLayer;

    for (int i = 0; i <= G.iVexNum; ++i)
    {
        G.adjList[i].data = i;
        G.adjList[i].pFirstEdge = NULL;
    }

    for (int i = 0; i <= G.iEdgeNum; ++i)
    {
        VertexType first;
        VertexType second;
        int weight;
        in >> first >> second >> weight;
        int m = GetIndexByVertexVal(G, first);
        int n = GetIndexByVertexVal(G, second);
        if (m == -1 || n == -1)
            return;
        EdgeNode* pEdgeNode = new EdgeNode;
        pEdgeNode->adjvex = n;
        pEdgeNode->weight = weight;  //权值 

        //表头插入法  
        pEdgeNode->next = G.adjList[m].pFirstEdge;
        G.adjList[m].pFirstEdge = pEdgeNode;
    }
}

void BGRAPH(int k,int n,int P[], AdjListGraph& G)
{
    for (int i = 0; i <= n; i++)
        BCOST[i] = MAXCOST;

    int r=0, j;
    BCOST[1] = 0;

    for (j = 2; j <= n; j++)
    {
        EdgeNode* pEdge = G.adjList[j].pFirstEdge;
        int _r;
        while (pEdge)
        {
            _r = pEdge->adjvex;
            if (BCOST[_r] + pEdge->weight <BCOST[j])
            {
                r = _r;
                BCOST[j] = BCOST[r] + pEdge->weight;
            }
            pEdge = pEdge->next;
        }

        D[j] = r;
    }
    P[1] = 1;
    P[k] = n;
    for (j = k - 1; j >= 2; j--)
    {
        P[j] = D[P[j + 1]];
    }

}

int main()
{
    //创建有向图  
    AdjListGraph G;
    CreateAdjListGraph(G);
    cout << endl;
    int k = 0;
    for (int i = 1; i <= 12; i++)
    {
        cout << i ;
        EdgeNode* pEdge = G.adjList[i].pFirstEdge;
        while (pEdge)
        {
            cout << " => " << pEdge->adjvex << "(" << pEdge->weight<<")"; k++;
            pEdge = pEdge->next;
        }
        cout << endl;
    }

    BGRAPH(G.iLayer, G.iVexNum, P, G);
    cout << endl;
    for (int i = 1; i <= G.iLayer; i++)
    {
        cout << "=>"<<P[i];
    }
    cout << endl;
    system("pause");
    return 0;
}

运行结果