DFS + Memoized solution getting TLE on LeetCode

Question

I was trying to solve this problem in a contest(now completed) on LeetCode .

In a group of N people (labelled 0, 1, 2, ..., N-1), each person has different amounts of money, and different levels of quietness.

For convenience, we'll call the person with label x, simply "person x".

We'll say that richer[i] = [x, y] if person x definitely has more money than person y. Note that richer may only be a subset of valid observations.

Also, we'll say quiet[x] = q if person x has quietness q.

Now, return answer, where answer[x] = y if y is the least quiet person (that is, the person y with the smallest value of quiet[y]), among all people who definitely have equal to or more money than person x.

Example 1:

Input: richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,7,0] Output: [5,5,2,5,4,5,6,7] Explanation: answer[0] = 5. Person 5 has more money than 3, which has more money than 1, which has more money than 0. The only person who is quieter (has lower quiet[x]) is person 7, but it isn't clear if they have more money than person 0.

answer[7] = 7. Among all people that definitely have equal to or more money than person 7 (which could be persons 3, 4, 5, 6, or 7), the person who is the quietest (has lower quiet[x]) is person 7.

The other answers can be filled out with similar reasoning.

There are no cycles in the input.

This look like a straightforward DFS problem where we keep track of the quietness of the nodes in the path.

And my solution is this

class Solution {
 public:
  int doDFS(unordered_map<int, bool>& visited,
            unordered_map<int, vector<int> > graph, vector<int>& quiet,
            vector<int>& answer, int current) {
    if (visited.find(current) != visited.end()) {
      return answer[current];
    }
    int current_min = current;
    for (int i = 0; i < graph[current].size(); ++i) {
      int min_y = doDFS(visited, graph, quiet, answer, graph[current][i]);
      if (quiet[current_min] > quiet[min_y]) {
        current_min = min_y;
      }
    }
    answer[current] = current_min;
    visited[current] = true;
    return answer[current];
  }
  vector<int> loudAndRich(vector<vector<int> >& richer, vector<int>& quiet) {
    // vector<vector<int>> graph(quiet.size(), vector<int>());
    unordered_map<int, vector<int> > graph;
    vector<int> answer(quiet.size());
    unordered_map<int, bool> visited;
    for (int i = 0; i < richer.size(); ++i) {
      // cout << richer[i][1] << ' ' << richer[i][0] << endl;
      if (graph.find(richer[i][1]) == graph.end()) {
        graph.insert({richer[i][1], vector<int>{richer[i][0]}});
      } else {
        graph[richer[i][1]].push_back(richer[i][0]);
      }
    }
    for (int i = 0; i < quiet.size(); ++i) {
      if (visited.find(i) == visited.end()) {
        doDFS(visited, graph, quiet, answer, i);
      }
    }

    return answer;
  }
};

But I'm not able to get this accepted it gets timed out for larger input. The runtime of this solution is O(N) as we visit each node only once.

Could someone help me as to why this is getting timed out?

Answer 1

Change unordered_map<int, vector<int> > graph to unordered_map<int, vector<int> > &graph , you are making a copy on each call which is giving you tle. With that change, it gets accepted.