Merge pull request #1542 from PDKhan/main

Author: PDKhan

course-schedule/PDKhan.cpp

@@ -0,0 +1,80 @@
+//DFS
+class Solution {
+    public:
+        bool dfs(int curr, vector<vector<int>>& graph, vector<int>& visited){
+            if(visited[curr] == 1)
+                return false;
+            
+            if(visited[curr] == 2)
+                return true;
+    
+            visited[curr] = 1;
+    
+            for(int i = 0; i < graph[curr].size(); i++){
+                if(dfs(graph[curr][i], graph, visited) == false)
+                    return false;
+            }
+    
+            visited[curr] = 2;
+    
+            return true;
+        }
+    
+        bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
+            vector<vector<int>> graph (numCourses);
+            vector<int> visited (numCourses, 0);
+    
+            for(int i = 0; i < prerequisites.size(); i++){
+                int course = prerequisites[i][0];
+                int pre = prerequisites[i][1];
+    
+                graph[pre].push_back(course);
+            }
+    
+            for(int i = 0; i < numCourses; i++){
+                if(dfs(i, graph, visited) == false)
+                    return false;
+            }
+    
+            return true;
+        }
+    };
+
+// BFS
+class Solution {
+    public:
+        bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
+            vector<vector<int>> graph (numCourses);
+            vector<int> inDegree (numCourses, 0);
+    
+            for(int i = 0; i < prerequisites.size(); i++){
+                int course = prerequisites[i][0];
+                int pre = prerequisites[i][1];
+    
+                graph[pre].push_back(course);
+                inDegree[course]++;
+            }
+    
+            queue<int> q;
+    
+            for(int i = 0; i < numCourses; i++){
+                if(inDegree[i] == 0)
+                    q.push(i);
+            }
+    
+            int count = 0;
+    
+            while(!q.empty()){
+                int curr = q.front();
+                q.pop();
+                count++;
+    
+                for(int i = 0; i < graph[curr].size(); i++){
+                    if(--inDegree[graph[curr][i]] == 0)
+                        q.push(graph[curr][i]);
+                }
+            }
+    
+            return count == numCourses;;
+        }
+    };

invert-binary-tree/PDKhan.cpp

@@ -0,0 +1,14 @@
+class Solution {
+    public:
+        TreeNode* invertTree(TreeNode* root) {
+            if(root == NULL)
+                return NULL;
+    
+            TreeNode* tmp = root->left;
+    
+            root->left = invertTree(root->right);
+            root->right = invertTree(tmp);
+    
+            return root;
+        }
+    };

jump-game/PDKhan.cpp

@@ -0,0 +1,13 @@
+class Solution {
+    public:
+        bool canJump(vector<int>& nums) {
+            int goal = nums.size() - 1;
+    
+            for(int i = nums.size() - 2; i >= 0; i--){
+                if(nums[i] + i >= goal)
+                    goal = i;
+            }
+    
+            return goal == 0;
+        }
+    };

merge-k-sorted-lists/PDKhan.cpp

@@ -0,0 +1,36 @@
+struct Compare{
+    bool operator()(ListNode* a, ListNode* b){
+        return a->val > b->val;
+    }
+};
+
+class Solution {
+public:
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+        priority_queue<ListNode*, vector<ListNode*>, Compare> pq;
+        ListNode* head = nullptr;
+        ListNode* tail;
+
+        for(ListNode* node : lists){
+            if(node) pq.push(node);
+        }
+
+        while(!pq.empty()){
+            ListNode* node = pq.top();
+
+            pq.pop();
+            if(head == nullptr){
+                head = node;
+                tail = head;
+            }else{
+                tail->next = node;
+                tail = tail->next;
+            }
+
+            if(node->next)
+                pq.push(node->next);
+        }
+
+        return head;
+    }
+};

search-in-rotated-sorted-array/PDKhan.cpp

@@ -0,0 +1,28 @@
+class Solution {
+    public:
+        int search(vector<int>& nums, int target) {
+            int start = 0;
+            int end = nums.size() - 1;
+    
+            while(start <= end){
+                int mid = start + (end - start) / 2;
+    
+                if(nums[mid] == target)
+                    return mid;
+                
+                if(nums[start] <= nums[mid]){
+                    if(nums[start] <= target && nums[mid] > target)
+                        end = mid - 1;
+                    else
+                        start = mid + 1;
+                }else{
+                    if(nums[mid] < target && nums[end] >= target)
+                        start = mid + 1;
+                    else
+                        end = mid - 1;
+                }
+            }
+    
+            return -1;
+        }
+    };