NetworkDelayTime

class Solution {
public:
    int maxDist(vector<int> d) {
        int m = d[1];
        for (int i = 1; i < d.size(); i++) {
            cout << d[i] << " ";
            if (d[i] > m) {
                m = d[i];
            }
            if (d[i] == INT_MAX) {
                return -1;
            }
        }
        return m;
    }

    void signalTravel(map <int, vector<pair<int, int>>> nd, vector<int> &d, int K, int dist) {
        map <int, vector<pair<int,int>>> :: iterator it;

        it = nd.find(K);

        if (it == nd.end()) {
            return;
        }
        vector<pair<int, int>> temp = it -> second;
        for (int i = 0; i < temp.size(); i++) {
            dist += temp[i].second;
            if (d[temp[i].first] == INT_MAX || d[temp[i].first] > dist) {
                d[temp[i].first] = dist;
                signalTravel(nd, d, temp[i].first, dist);
            }
            dist -= temp[i].second;
        }
        return;
    }

    int networkDelayTime(vector<vector<int>> times, int N, int K) {
        map <int, vector<pair<int, int>>> nd;

        //yeah, this map looks like monster
        map <int, vector<pair<int, int>>> :: iterator it;

        //converting containers
        for (int i = 0; i < times.size(); i++) {
            it = nd.find(times[i][0]);
            if (it == nd.end()) {
                vector <pair<int,int>> vnl;
                vnl.push_back(make_pair(times[i][1], times[i][2]));
                nd.insert(make_pair(times[i][0], vnl));
            } else {
                vector <pair<int,int>> vnl;
                vnl = it -> second;
                vnl.push_back(make_pair(times[i][1], times[i][2]));
                it -> second = vnl;
            }
        }

        vector <int> d(N + 1, INT_MAX);
        d[K] = 0;
        signalTravel(nd, d, K, 0);
        return maxDist(d);
    }
};