城市间紧急救援(C++)

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式:
输入第一行给出4个正整数N、M、S、D，其中N（2≤N≤500）是城市的个数，顺便假设城市的编号为0 ~ (N−1)；M是快速道路的条数；S是出发地的城市编号；D是目的地的城市编号。

第二行给出N个正整数，其中第i个数是第i个城市的救援队的数目，数字间以空格分隔。随后的M行中，每行给出一条快速道路的信息，分别是：城市1、城市2、快速道路的长度，中间用空格分开，数字均为整数且不超过500。输入保证救援可行且最优解唯一。

输出格式:
第一行输出最短路径的条数和能够召集的最多的救援队数量。第二行输出从S到D的路径中经过的城市编号。数字间以空格分隔，输出结尾不能有多余空格。

输入样例:
4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2
输出样例:
2 60
0 1 3

#include<iostream>
#include<string.h>
#include<vector>
#include<stack>
using namespace std;

#define MAX 100000

bool exist(vector<int> a ,int b);
int calculate(vector<int> a,int *b);


class Graph
{
public:
	int Nv;
	int Ne;
	int **Matrix;
    int *path;
    int *dis;
    stack< vector<int> > shortest_way; 
    stack< vector<int> > final_result_way;
public:
	Graph(int Nv , int Ne)
	{
		int i,j,x,y,weight;
		this->Nv = Nv;
		this->Ne = Ne;
		Matrix = new int*[Nv];
        path = new int[Nv];
        dis = new int[Nv];
		for(i = 0 ; i < Nv ; i++)
		{
			Matrix[i] = new int[Nv];
		}
		for(i = 0 ; i < Nv ; i++)
			for(j = 0 ; j < Nv ; j++)
			{
                if(i == j)
                    Matrix[i][j] = 0;
                else
				    Matrix[i][j] = MAX;
			}
		for(i = 0 ; i < Ne ; i++)
		{
			cin>>x>>y>>weight;
			Matrix[x][y] = weight;
			Matrix[y][x] = weight;
		}
	}
    


    void Dijkstra(int st)
    {
        // int path[Nv];
        // int dis[Nv];
        int vis[Nv];
        int i,p,min;
        for(i = 0 ; i < Nv ; i++)
        {
            vis[i] = 0;
            dis[i] = Matrix[st][i];
            if(dis[i] != 100000)
            {
                path[i] = st;
            }
            else
                path[i] = -1;
        }
        
        path[st] = -1;
        vis[st] = 1;
        while(true)
        {
            p = -1;
            min = MAX;
            for(i = 0 ; i < Nv ; i++)
            {
                if(vis[i] == 0 && dis[i] < min)
                {
                    min = dis[i];
                    p = i;
                }
            }
            vis[p] = 1;
            if(p == -1)
                break;
            for(i = 0 ; i < Nv ; i++)
            {
                if(vis[i] == 0 && dis[i] > min + Matrix[p][i])
                {
                    dis[i] = min + Matrix[p][i];
                    path[i] = p;
                }
            }
        }
    }

    void Print(int st,int ed)
    {
        Dijkstra(st);
        stack<int> s;
        int k = ed,i;
        s.push(k);
        while(path[k] != -1)
        {
            k = path[k];
            s.push(k);
        }
        int n = s.size();
        for(i = 0 ; i < n ; i++)
        {
            k = s.top();
            s.pop();   
            if(i != n-1)
                cout<<k<<"->";
            else
                cout<<k;
        }


    }

    void Find(int st,int ed)
    {
        int i;
        Dijkstra(st);
        vector<int> way1;
        way1.push_back(ed);

        shortest_way.push(way1);
        int cur_v;


        while(!shortest_way.empty())
        {
            vector<int> way2 = shortest_way.top();
            shortest_way.pop();
            cur_v = way2[way2.size()-1];
            if(cur_v == st)
            {
                final_result_way.push(way2);
            }
            else
            {
                for(i = 0 ; i < Nv ; i++)
                {
                    if( ( Matrix[i][cur_v] < MAX ) && ( dis[i] + Matrix[i][cur_v] == dis[cur_v] ) && (!exist(way2,i)) )
                    {
                        vector<int> way3 = way2;
                        way3.push_back(i);        

                        shortest_way.push(way3);
                    }
                }
            }

        }

        
        
    }










};

int calculate(vector<int> a,int *b)
{
    int i,sum = 0;
    for(i = 0 ; i < a.size() ; i++)
    {
        sum +=  b[a[i]];
    }
    return sum;
}

bool exist(vector<int> a ,int b)
{
    int i;
    for(i = 0 ; i < a.size() ; i++)
    {
        if(b == a[i])
            return true;
    }
    return false;
}





int main()
{
	int N,M,S,D,i,x,j,sum = 0;
	cin>>N>>M>>S>>D;
    vector<int> a,b;
	int *city = new int[N];
	for(i = 0 ; i < N ; i++)
	{
		cin>>x;
		city[i] = x;
	}
	Graph G(N,M);
    G.Dijkstra(S);
    // for(i = 0 ; i < G.Nv ; i++)
    // {
    //     cout<<G.dis[i]<<" ";
    // }
    // G.Print(S,D);
    G.Find(S,D);
    int n = G.final_result_way.size();
    vector<int> temp,path;
    while(!G.final_result_way.empty())
    {
        temp = G.final_result_way.top();
        G.final_result_way.pop();
        if(sum < calculate(temp,city))
        {
            sum = calculate(temp,city);
            path = temp;
        }

    }
    cout<<n<<" "<<sum<<endl;
    for(i = path.size()-1 ; i >= 0 ; i--)
    {
        if(i != 0)
            cout<<path[i]<<" ";
        else
            cout<<path[i];
    }

    return 0;
}