🚀 25-Jul-2020

Author: sureshmangs

competitive programming/leetcode/2020-July-Challenge/Day-24-All Paths From Source to Target.cpp

@@ -0,0 +1,53 @@
+Given a directed, acyclic graph of N nodes.  Find all possible paths from node 0 to node N-1, and return them in any order.
+
+The graph is given as follows:  the nodes are 0, 1, ..., graph.length - 1.  graph[i] is a list of all nodes j for which the edge (i, j) exists.
+
+Example:
+Input: [[1,2], [3], [3], []]
+Output: [[0,1,3],[0,2,3]]
+Explanation: The graph looks like this:
+0--->1
+|    |
+v    v
+2--->3
+There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.
+Note:
+
+The number of nodes in the graph will be in the range [2, 15].
+You can print different paths in any order, but you should keep the order of nodes inside one path.
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    void dfs(vector<vector<int> > &graph, int src, int dst, vector<int> &curr, vector<vector<int>> &res){
+        if(src==dst){
+            res.push_back(curr);
+            return;
+        }
+        for(auto x: graph[src]){
+            curr.push_back(x);
+            dfs(graph, x, dst, curr, res);
+            curr.erase(curr.end()-1);
+        }
+    }
+
+    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
+        vector<vector<int> > res;
+        vector<int> curr;
+        int n=graph.size();
+        curr.push_back(0);   // inserting src
+        dfs(graph, 0, n-1, curr, res);   // src --> 0    dst --> n-1
+        return res;
+    }
+};

competitive programming/leetcode/260. Single Number III.cpp

@@ -0,0 +1,37 @@
+Given an array of numbers nums, in which exactly two elements appear only once and all the other elements appear exactly twice. Find the two elements that appear only once.
+
+Example:
+
+Input:  [1,2,1,3,2,5]
+Output: [3,5]
+Note:
+
+The order of the result is not important. So in the above example, [5, 3] is also correct.
+Your algorithm should run in linear runtime complexity. Could you implement it using only constant space complexity?
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> singleNumber(vector<int>& nums) {
+        vector<int> res(2, 0);
+        int xor2=0;    // xor of 2 unique numbers
+        for(auto &x : nums){
+            xor2^=x;
+        }
+        int setBit=xor2 & (-xor2);    // set bit from rigth to left
+        for(auto x: nums){
+            if((setBit & x) == 0)
+                res[0]^=x;
+            else res[1]^=x;
+        }
+        return res;
+    }
+};

competitive programming/leetcode/797. All Paths From Source to Target.cpp

@@ -0,0 +1,53 @@
+Given a directed, acyclic graph of N nodes.  Find all possible paths from node 0 to node N-1, and return them in any order.
+
+The graph is given as follows:  the nodes are 0, 1, ..., graph.length - 1.  graph[i] is a list of all nodes j for which the edge (i, j) exists.
+
+Example:
+Input: [[1,2], [3], [3], []]
+Output: [[0,1,3],[0,2,3]]
+Explanation: The graph looks like this:
+0--->1
+|    |
+v    v
+2--->3
+There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.
+Note:
+
+The number of nodes in the graph will be in the range [2, 15].
+You can print different paths in any order, but you should keep the order of nodes inside one path.
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    void dfs(vector<vector<int> > &graph, int src, int dst, vector<int> &curr, vector<vector<int>> &res){
+        if(src==dst){
+            res.push_back(curr);
+            return;
+        }
+        for(auto x: graph[src]){
+            curr.push_back(x);
+            dfs(graph, x, dst, curr, res);
+            curr.erase(curr.end()-1);
+        }
+    }
+
+    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
+        vector<vector<int> > res;
+        vector<int> curr;
+        int n=graph.size();
+        curr.push_back(0);   // inserting src
+        dfs(graph, 0, n-1, curr, res);   // src --> 0    dst --> n-1
+        return res;
+    }
+};