Leetcode-Network Delay Time

Problem

There are N network nodes, labelled 1 to N.

Given times, a list of travel times as directed edges times[i] = (u, v, w), where u is the source node, v is the target node, and w is the time it takes for a signal to travel from source to target.

Now, we send a signal from a certain node K. How long will it take for all nodes to receive the signal? If it is impossible, return -1.
Note:
N will be in the range [1, 100].
K will be in the range [1, N].
The length of times will be in the range [1, 6000].
All edges times[i] = (u, v, w) will have 1 <= u, v <= N and 1 <= w <= 100.

具体详见Leetcode

Analysis

这道题是关于图的问题，求的是从某一个特定的点K出发到其它所有点的总时间。
这道题实际上是在应用迪杰斯特拉算法。把所有的顶点分为两个集合，一个集合是从K点出发到达的顶点集inside，另一个暂时还不能从K点出发到达的集合outside。一开始到达集合是空的，另一个集合中包含所有的点。然后维护一个dis数组，最开始dis[K-1]=0（坐标从0开始），其它点的dis值为101（最大值），然后遍历当前的集合outside，找到outside集合中dis值最小的点，成为新的加入到inside集合的点，因为新的点加入到inside集合中会对outside集合中的dis的值产生影响，所有对outside集合中每一个点检查，如果当前点的dis加上当前点到检查点的距离比原来检查点的dis小，更新检查点的dis值。
此题在迪杰斯特拉算法的基础上，在判断一个新加入inside集合的点的dis如果比当前最大时间大的话，更新最大时间max。
如果最后outside剩下的所有点的dis值都为101（最大值）的话，那么不存在路径从K到所有点的路径。

Complexity

时间复杂度：$O(V^2+E)$
空间复杂度：$O(N^2)$

Code

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {

        //initialize
        int* dis = new int[N];

        vector<int> inside;
        std::vector<int> outside;

        int** matrix = new int* [N];
        for (int i = 0; i < N; i++) {

            outside.push_back(i);
            matrix[i] = new int[N];
            for (int j = 0; j < N; j++) {
                if (i != j) matrix[i][j] = 101;
                else matrix[i][j] = 0;
            }
            dis[i] = 101;
        }
        dis[K-1] = 0;
        bool flag = true;
        for (int i = 0; i < times.size(); i++) {
            matrix[times[i][0]-1][times[i][1]-1] = times[i][2];

        }


        int max = 0;

        while (inside.size() < N) {


            int min = outside[0], mIndex = 0;

            if(min == K-1) {
                if (min+1 < N) min = min+1;
                else min = min-1;
            }
            for (int i = 0; i < outside.size(); i++) {
                if (dis[outside[i]] < dis[min]) {
                    min = outside[i];
                    mIndex = i;
                }
            }

            if (dis[min] == 101) {
                flag = false;
                break;
            }
            if (dis[min] > max) max = dis[min];
            outside.erase(outside.begin()+mIndex);
            inside.push_back(min);
            for (int i = 0; i < N; i++) {
                if ((dis[min]+matrix[min][i]) < dis[i]) {
                    dis[i] = dis[min]+matrix[min][i];
                }
            }

        }
        for(int i = 0; i < N; i++)
            delete []matrix[i];
        delete []matrix;
        delete []dis;
        if (!flag) return -1;

        return max;
    }
};