作者: Turbo時間限制: 1S章節: DS:圖

晚於: 2020-08-05 12:00:00後提交分數乘係數50%

截止日期: 2020-08-12 12:00:00

問題描述 :

有 N 個網路節點，標記為 1 到 N。

給定一個列表 times，表示訊號經過有向邊的傳遞時間。 times[i] = (u, v, w)，其中 u 是源節點，v 是目標節點， w 是一個訊號從源節點傳遞到目標節點的時間。

現在，我們從某個節點 K 發出一個訊號。需要多久才能使所有節點都收到訊號？如果不能使所有節點收到訊號，返回 -1。

示例：

輸入：times = [[2,1,1],[2,3,1],[3,4,1]], N = 4, K = 2

輸出：2

可使用以下main函式：

int main()

{

int N,M,K;

vector<vector<int> > times;

cin>>N>>M>>K;

int u,v,w;

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

{

cin>>u>>v>>w;

vector<int> time;

time.push_back(u);

time.push_back(v);

time.push_back(w);

times.push_back(time);

}

int res=Solution().networkDelayTime(times,N,K);

cout<<res<<endl;

}

輸入說明 :

首先輸入網路節點個數N，傳遞時間列表 times的長度M，起始節點K

然後輸入M行，每行三個整數(u, v, w)，其中 u 是源節點，v 是目標節點， w 是一個訊號從源節點傳遞到目標節點的時間。

N 的範圍在 [1, 100] 之間。

K 的範圍在 [1, N] 之間。

times 的長度M在 [1, 6000] 之間。

所有的邊 times[i] = (u, v, w) 都有 1 <= u, v <= N 且 0 <= w <= 100。

輸出說明 :

輸出一個整數，表示結果。

輸入範例 :

4 3 2 2 1 1 2 3 1 3 4 1

輸出範例 :

2

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; 
class Solution {
public:
    int flag = 1000;
    vector<vector<int>> G;//圖
    int n;
    int root;//源節點
    vector<int> set;//儲存已找到最短路徑的結點
    vector<int> dis;//儲存最短路徑
    void dijkstra()
    {
        set[root] = 1;
        dis[root] = 0;
        for (int i = 1; i <= n; i++)
        {
            int k = 0;
            for (int j = 1; j <= n; j++)//找出距離最近的點
                if (!set[j] && (k == 0 || dis[j] < dis[k]))
                    k = j;
            set[k] = 1;//加入集合
            for (int j = 1; j <= n; ++j)//更新
                if (!set[j] && dis[k] + G[k][j] < dis[j])
                    dis[j] = dis[k] + G[k][j];
        }
    }
    int networkDelayTime(vector<vector<int>>& times, int N, int K)
    {
        G.resize(N+1,vector<int>(N+1,flag));
        
        root = K;
        n = N;
        dis.resize(N + 1, flag);//容量加1是因為也要儲存本身的節點 
        set.resize(N + 1, 0);
        for (auto temp : times)
        {
            if (temp[0] == K)
                dis[temp[1]] = temp[2];
            G[temp[0]][temp[1]] = temp[2];
        }
        dijkstra();
        int res = *max_element(dis.begin() + 1, dis.end());
        return res == flag ? -1 : res;
    }
};
int main()
{
    int N,M,K;
    vector<vector<int> > times;
    cin>>N>>M>>K;
    int u,v,w;
    for(int i=0; i<M; i++)
    {
        cin>>u>>v>>w;
        vector<int> time;
        time.push_back(u);
        time.push_back(v);
        time.push_back(w);
        times.push_back(time);
    }
    int res=Solution().networkDelayTime(times,N,K);
    cout<<res<<endl;
}