PAT 紧急救援 （最短路径变形）

题目链接，戳我

# include <iostream>
# include <stdlib.h>
# include <string.h>
# define MAX 505
# define INFI 999
using namespace std;
int N,M,S,D;
int valueOfVer[MAX];//顶点值，即每个城市的救援队 
int preVer[MAX];//preVer[V] = B  V的前驱节点为B。记录前驱节点，用于找最佳路径 
int visit[MAX];//标记 顶点是否被访问过 
int totalOfVer[MAX];//从出发点到某个个顶点，最大召集的数量。 totalOfVer[A] = 10，代表：从出发点到A最多召集的数量为10 
int path[MAX][MAX];//记录两顶点间的联系 
int lowcost[MAX];//最低花费，即出发点到各顶点的最短路径 
int numOfPath[MAX];//最短路径的条数 
void Dij()
{
    memset(visit,0,sizeof(visit));
    memset(preVer,0,sizeof(preVer));
    memset(totalOfVer,0,sizeof(totalOfVer));

    for(int i=0; i<N; ++i)
    {
        lowcost[i] = path[S][i];
        if(lowcost[i] != INFI)
            preVer[i] = S;
        numOfPath[i] = 1;
        if(i != S && path[S][i] != INFI)//从出发点出发，到 ---与出发点相联通  的顶点--所能召集的救援队  
            totalOfVer[i] = valueOfVer[S] + valueOfVer[i];
    }
    //对出发点做初始化操作 
    lowcost[S] = 0;
    visit[S] = 1;
    totalOfVer[S] = valueOfVer[S];

    for(int i=0; i<N-1; ++i)
    {
        int min = INFI;
        int k;

        for(int j=0; j<N; ++j)
        {
            if(!visit[j] && min>lowcost[j])
            {
                min = lowcost[j];
                k = j;      
            }   
        }   

        visit[k] = 1;


        for(int j=0; j<N; ++j)//在这个循环里面，做附加操作（记录路径，统计路径） 
        {
            if(!visit[j])
            {
                if(lowcost[k] + path[k][j] < lowcost[j])//最短路径 
                {
                    //目前最短路径只有一条，所以，到达j的最短路径，就是从出发点到K的最短路径条数 
                    numOfPath[j] = numOfPath[k];


                    lowcost[j] = lowcost[k] + path[k][j];
                    preVer[j] = k;//记录前驱节点 
                    totalOfVer[j] = totalOfVer[k] + valueOfVer[j];//j顶点所能召集的救援队的总数量 
                }
                else if(lowcost[k] + path[k][j] == lowcost[j])//有重复的路径 
                {
                    numOfPath[j] += numOfPath[k];//条数在本身的基础上 再增加 


                    //最新的最短路径 如果召集的人数没有原来的多，则前驱节点不需要修改 
                    if( totalOfVer[j] < totalOfVer[k] + valueOfVer[j])
                    {
                        totalOfVer[j] = totalOfVer[k] + valueOfVer[j];
                        preVer[j] = k;
                    }
                }
            }   
        }

    }
}

int main(void)
{
//  freopen("input.txt","r",stdin);
    cin >> N >> M >> S >> D;

    for(int i=0; i<N; ++i)
        cin >> valueOfVer[i];

    for(int i=0; i<N; ++i)
    {
        for(int j=0; j<N; ++j)
            path[i][j] = INFI;
    }


    for(int i=0; i<M; ++i)
    {
        int j,k,l;
        cin >> j >> k >> l;
        path[j][k] = l;
        path[k][j] = l;
    }

    Dij();

    cout << numOfPath[D] <<' '<< totalOfVer[D] << endl;

    int cur = D;//从目的城市出发，打印路径到数组当中 
    int ans[MAX],index=0;
    while(cur != S)
    {
        ans[index++] = cur;
        cur = preVer[cur];
    }
    ans[index++] = S;
    for(int i=index-1; i>=0; --i)
    {
        cout << ans[i];
        if(i > 0) cout << ' ';
        else cout << endl;
    }

//  fclose(stdin);
    return 0;
}

思路：
在最基本的最短路径上，要做
1、记录最短路径：利用一维数组，记录A顶点的前驱节点，即preVer[A] = B，B即是A的前驱
2、统计最短路径条数：如果某次借助中间顶点到的顶点B，路径长度正好等于B的最短路径长度，则有重复的最短路径（针对当前来说，因为，还有可以其它路径比这些路径短）
3、其他的，也没什么了。。