last task

LeetCodeTasks.cpp

@@ -1,50 +1,56 @@
 
+#include <chrono>
 #include <iostream>
 #include <map>
+#include <queue>
+#include <stack>
 #include <vector>
 
-using namespace std;
+bool get_point_safe(std::vector<std::vector<int>>& graph, std::vector<int>& visited, int point)
+{
+    if (graph[point].empty())
+    {
+        visited[point] = -1;
+        return true;
+    }
+    if (visited[point] == 2)
+    {
+        return false;
+    }
+    visited[point] = 1;
+    for (int i = 0; i < graph[point].size(); i++)
+    {
+        if (visited[graph[point][i]] == 1 || visited[graph[point][i]] == 2)
+        {
+            visited[point] = 2;
+            return false;
+        }
+        else if (visited[graph[point][i]] == -1) {
+            continue;
+        }
+        if (!get_point_safe(graph, visited, graph[point][i]))
+        {
+            visited[point] = 2;
+            return false;
+        }
+    }
+    visited[point] = -1;
+    return true;
+}
 
 class Solution {
 public:
-    int countServers(vector<vector<int>>& grid) {
-        int count = 0;
-        for (int y = 0; y < grid.size(); y++) {
-            for (int x = 0; x < grid[0].size(); x++) {
-                if (grid[y][x] == 0)
-                {
-                    continue;
-                }
-                grid[y][x] = 0;
-                vector<pair<int, int>> connection{ {y,x} };
-                for (auto index = 0; index < connection.size(); index++) {
-                    std::pair<int, int> point{ connection[index] };
-                    for (int i = 0; i < grid.size(); i++)
-                    {
-                        if (grid[i][point.second] == 1)
-                        {
-                            grid[i][point.second] = 0;
-                            connection.emplace_back(i, point.second);
-                        }
-                    }
-
-                    for (int j = 0; j < grid[0].size(); j++)
-                    {
-                        if (grid[point.first][j] == 1)
-                        {
-                            grid[point.first][j] = 0;
-                            connection.emplace_back(point.first, j);
-                        }
-                    }
-                }
-                if (connection.size() > 1)
-                {
-                    count += connection.size();
-                }
+    std::vector<int> eventualSafeNodes(std::vector<std::vector<int>>& graph) {
+        std::vector<int> visited(graph.size(), 0);
+        std::vector<int> res;
+        for (int i = 0; i < graph.size(); i++)
+        {
+            if (get_point_safe(graph, visited, i))
+            {
+                res.push_back(i);
             }
-
         }
-        return count;
+        return res;
     }
 };
 
@@ -75,8 +81,15 @@ std::vector<std::vector<int>> process_input(std::string& input)
 int main()
 {
     Solution sol;
-    std::string input{ "[[1,0],[1,1]]" };
-    std::vector<std::vector<int>> grid = process_input(input);
-    long long res = sol.countServers(grid);
-    std::cout << res;
+    std::string input{ "[[1,2],[2,3],[5],[0],[5],[],[]]" };
+	std::vector<std::vector<int>> grid = process_input(input);
+    auto start_time = std::chrono::steady_clock::now();
+    std::vector<int> res = sol.eventualSafeNodes(grid);
+    auto end_time = std::chrono::steady_clock::now();
+    auto elapsed_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
+    for (auto x: res)
+    {
+        std::cout << x << " ";
+    }
+    std::cout << "\n" << elapsed_ns.count() << " ns\n";
 }