Add new solution with explanation

Author: SartHak-0-Sach

181-29th_June-Ancestors_of_node_in_acyclic_graph/approach-explanation.txt

@@ -0,0 +1,15 @@
+Intuition
+The intuition behind the approach is to use a DFS to traverse the graph and find the ancestors of each node. By starting the DFS from each node and adding the current node to the ans list of its children, we ensure that all the ancestors of a node are recorded in the ans list of that node.
+The directChild list is used to keep track of the direct children of each node, which helps in efficiently traversing the graph during the DFS.
+
+Approach
+The approach used in the code is a depth-first search (DFS) to find the ancestors of each node in the graph represented by the given edges.
+
+Initialize two lists: ans to store the ancestors of each node, and directChild(dc) to store the direct children of each node.
+Iterate through the edges list and add each child node to the directChild(dc) list of its parent node.
+Iterate through the nodes from 0 to n-1 and perform a DFS starting from each node.
+In the DFS function, for each child node of the current node, check if the current node is not already present in the ans list of the child node. If not, add the current node to the ans list of the child node and recursively call the DFS function with the child node as the new current node.
+Return the ans list as the final result.
+Complexity
+Time complexity:O(n + m)
+Space complexity:O(n + m)

181-29th_June-Ancestors_of_node_in_acyclic_graph/code.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+class Solution {
+public:
+    vector<vector<int>> getAncestors(int n, vector<vector<int>>& edges) {
+        vector<vector<int>> ans(n), directChild(n);
+        for (auto& e : edges) {
+            directChild[e[0]].push_back(e[1]);
+        }
+        for (int i = 0; i < n; i++) {
+            dfs(i, i, ans, directChild);
+        }
+        return ans;
+    }
+
+private:
+    void dfs(int x, int curr, vector<vector<int>>& ans, vector<vector<int>>& directChild) {
+        for (int ch : directChild[curr]) {
+            if (ans[ch].empty() || ans[ch].back() != x) {
+                ans[ch].push_back(x);
+                dfs(x, ch, ans, directChild);
+            }
+        }
+    }
+};