Added Graph and Heap Qs

Author: devangi2000

Binary-Search/ArrangingCoins441.cpp

@@ -0,0 +1,32 @@
+// You have n coins and you want to build a staircase with these coins. The staircase consists of k rows where 
+// the ith row has exactly i coins. The last row of the staircase may be incomplete.
+// Given the integer n, return the number of complete rows of the staircase you will build.
+
+// Example 1:
+// Input: n = 5
+// Output: 2
+// Explanation: Because the 3rd row is incomplete, we return 2.
+// Example 2:
+// Input: n = 8
+// Output: 3
+// Explanation: Because the 4th row is incomplete, we return 3. 
+
+// Constraints:
+// 1 <= n <= 231 - 1
+
+class Solution {
+public:
+    int arrangeCoins(int n) {
+        long left = 0, right = n, curr, mid;
+        while(left <= right){
+            mid = left + (right - left) / 2;
+            curr = (mid * (mid + 1)) / 2;
+            if(curr == n)
+                return mid;
+            else if(curr < n)
+                left = mid + 1;
+            else right =  mid - 1;
+        }
+        return right;
+    }
+};

Binary-Search/ArrangingCoins441.java

@@ -0,0 +1,29 @@
+// You have n coins and you want to build a staircase with these coins. The staircase consists of k rows where 
+// the ith row has exactly i coins. The last row of the staircase may be incomplete.
+// Given the integer n, return the number of complete rows of the staircase you will build.
+
+// Example 1:
+// Input: n = 5
+// Output: 2
+// Explanation: Because the 3rd row is incomplete, we return 2.
+// Example 2:
+// Input: n = 8
+// Output: 3
+// Explanation: Because the 4th row is incomplete, we return 3. 
+
+// Constraints:
+// 1 <= n <= 231 - 1
+
+class Solution {
+    public int arrangeCoins(int n) {
+        long curr = 0, mid = 0, left = 0, right = n;
+        while(left <= right){
+            mid = left + (right - left) / 2;
+            curr = mid * (mid + 1) / 2;
+            if(curr == n) return (int) mid;
+            if(curr < n) left = mid + 1;
+            else right = mid - 1;
+        }
+        return (int) right;
+    }
+}

Graphs/BFS-Traversal.java

@@ -0,0 +1,61 @@
+// https://practice.geeksforgeeks.org/problems/bfs-traversal-of-graph/1
+// Given a directed graph. The task is to do Breadth First Traversal of this graph starting from 0.
+// Note: One can move from node u to node v only if there's an edge from u to v and find the BFS traversal of the graph starting from the 0th vertex, from left to right according to the graph. Also, you should only take nodes directly or indirectly connected from Node 0 in consideration.
+// Example 1:
+
+// Input:
+
+// Output: 0 1 2 3 4
+// Explanation: 
+// 0 is connected to 1 , 2 , 3.
+// 2 is connected to 4.
+// so starting from 0, it will go to 1 then 2
+// then 3.After this 2 to 4, thus bfs will be
+// 0 1 2 3 4.
+// Example 2:
+
+// Input:
+
+// Output: 0 1 2
+// Explanation:
+// 0 is connected to 1 , 2.
+// so starting from 0, it will go to 1 then 2,
+// thus bfs will be 0 1 2 3 4. 
+
+// Expected Time Complexity: O(V + E)
+// Expected Auxiliary Space: O(V)
+
+
+// Constraints:
+// 1 ≤ V, E ≤ 104
+
+// Company Tags
+// Topic Tags
+// Related Courses
+// Related Interview Experiences
+
+// If you are facing any issue on this page. Please let us know.
+
+// Output Window
+
+class Solution {
+    // Function to return Breadth First Traversal of given graph.
+    public ArrayList<Integer> bfsOfGraph(int V, ArrayList<ArrayList<Integer>> adj) {
+        int[] visited = new int[V];
+        ArrayList<Integer> ans = new ArrayList<>();
+        Queue<Integer> q = new LinkedList<>();
+        q.offer(0);
+        visited[0] = 1;
+        while(!q.isEmpty()){
+            int curr = q.poll();
+            ans.add(curr);
+            for(int num : adj.get(curr)){
+                if(visited[num] == 0){
+                    visited[num] = 1;
+                    q.offer(num);
+                }
+            }
+        }
+        return ans;
+    }
+}

Graphs/DFS-Traversal.java

@@ -0,0 +1,57 @@
+// https://practice.geeksforgeeks.org/problems/depth-first-traversal-for-a-graph/1
+
+// Given a connected undirected graph. Perform a Depth First Traversal of the graph.
+// Note: Use recursive approach to find the DFS traversal of the graph starting from the 0th vertex from left to right according to the graph..
+
+// Example 1:
+
+// Input:
+
+// Output: 0 1 2 4 3
+// Explanation: 
+// 0 is connected to 1, 2, 4.
+// 1 is connected to 0.
+// 2 is connected to 0.
+// 3 is connected to 0.
+// 4 is connected to 0, 3.
+// so starting from 0, it will go to 1 then 2
+// then 4, and then from 4 to 3.
+// Thus dfs will be 0 1 2 4 3.
+// Example 2:
+
+// Input:
+
+// Output: 0 1 2 3
+// Explanation:
+// 0 is connected to 1 , 3.
+// 1 is connected to 2. 
+// 2 is connected to 1.
+// 3 is connected to 0. 
+// so starting from 0, it will go to 1 then 2
+// then back to 0 then 0 to 3
+// thus dfs will be 0 1 2 3. 
+
+// Expected Time Complexity: O(V + E)
+// Expected Auxiliary Space: O(V)
+
+// Constraints:
+// 1 ≤ V, E ≤ 104
+
+
+class Solution {
+    public void dfs(int i, ArrayList<ArrayList<Integer>> adj, int[] visited, ArrayList<Integer> ans){
+        visited[i] = 1;
+        ans.add(i);
+        for(int num : adj.get(i)){
+            if(visited[num] == 0) 
+                dfs(num, adj, visited, ans);
+        }
+        return;
+    }
+    public ArrayList<Integer> dfsOfGraph(int V, ArrayList<ArrayList<Integer>> adj) {
+        int[] visited = new int[V];
+        ArrayList<Integer> ans = new ArrayList<>();
+        dfs(0, adj, visited, ans);
+        return ans;
+    }
+}

Graphs/Detect-Cycle-in-Undirected-Graph_BFS.cpp

@@ -0,0 +1,42 @@
+// https://practice.geeksforgeeks.org/problems/detect-cycle-in-an-undirected-graph/1/?page=1&category[]=Graph&query=page1category[]Graph#
+// Given an undirected graph with V vertices and E edges, check whether it contains any cycle or not. 
+
+bool bfs(vector<int> adj[], int source, int V, vector<bool> &visited) {
+    queue<int> q;
+    q.push(source);
+    // mark the source node as visited
+    visited[source] = true;
+    vector<int> parent(V, -1);
+
+    // apply BFS
+    while(!q.empty()) {
+        int front = q.front();
+        q.pop();
+
+        // visit the neighbours of this node
+        for(int &nbr : adj[front]) {
+            if(!visited[nbr]) {
+                visited[nbr] = true;
+                parent[nbr] = front;
+                q.push(nbr);
+            }
+            else if(parent[front] != nbr)
+                return true;
+        }
+    }
+    return false;
+}
+
+// the graph could contain disconnected components as well
+bool isCycle(int V, vector<int> adj[]) {
+    // initially mark all the nodes as unvisited
+    vector<bool> visited(V, false);
+    // go through each node and call BFS on each unvisited node
+    for(int i = 0; i < V; i++) {
+        // cycle is detected
+        if(!visited[i] && bfs(adj, i, V, visited))
+            return true;
+    }
+    return false;
+}
+© 2021 GitHub, Inc.

Graphs/Detect-Cycle-in-Undirected-Graph.cpp renamed to Graphs/Detect-Cycle-in-Undirected-Graph_DFS.cpp

@@ -0,0 +1,28 @@
+// Given an integer array nums and an integer k, return the kth largest element in the array.
+// Note that it is the kth largest element in the sorted order, not the kth distinct element.
+// Example 1:
+
+// Input: nums = [3,2,1,5,6,4], k = 2
+// Output: 5
+// Example 2:
+
+// Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
+// Output: 4
+ 
+
+// Constraints:
+
+// 1 <= k <= nums.length <= 104
+// -104 <= nums[i] <= 104
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        Queue<Integer> q = new PriorityQueue<>((a, b) -> b - a);
+        for(int num : nums){
+            q.offer(num);
+        }
+        for(int i = 1; i < k; i++)
+            q.poll();
+        return q.poll();
+    }
+}
+

Heap/Kth-Largest-Element-in-Array-215.java

@@ -28,7 +28,7 @@
 // -104 <= val <= 104
 // At most 104 calls will be made to add.
 // It is guaranteed that there will be at least k elements in the array when you search for the kth element.
-
+// Method 1
 class KthLargest {
 public:
     priority_queue<int, vector<int>, greater<int>> minHeap; 
@@ -56,3 +56,30 @@ class KthLargest {
  * KthLargest* obj = new KthLargest(k, nums);
  * int param_1 = obj->add(val);
  */
+
+// Method 2
+
+class MedianFinder {
+public:
+    priority_queue<long> maxHeap;
+    priority_queue<long, vector<long>, greater<long>> minHeap;
+    MedianFinder() {        
+    }    
+    void addNum(int num) {
+        if(maxHeap.empty() || maxHeap.top() > num) maxHeap.push(num);
+        else minHeap.push(num);        
+        if(maxHeap.size() > minHeap.size() + 1){
+            minHeap.push(maxHeap.top());
+            maxHeap.pop();
+        }
+        else if(minHeap.size() > maxHeap.size() + 1){
+            maxHeap.push(minHeap.top());
+            minHeap.pop();
+        }
+    }
+    
+    double findMedian() {
+        if(minHeap.size() == maxHeap.size()) return maxHeap.empty() ? 0 : (maxHeap.top() + minHeap.top()) / 2.0;
+        else return maxHeap.size() > minHeap.size() ? maxHeap.top() : minHeap.top();
+    }
+};

Heap/Kth-Largest-Element-in-Stream-703.cpp

@@ -0,0 +1,59 @@
+// Design a class to find the kth largest element in a stream. Note that it is the kth largest element in the sorted order, not the kth distinct element.
+// Implement KthLargest class:
+// KthLargest(int k, int[] nums) Initializes the object with the integer k and the stream of integers nums.
+// int add(int val) Returns the element representing the kth largest element in the stream.
+
+// Example 1:
+
+// Input
+// ["KthLargest", "add", "add", "add", "add", "add"]
+// [[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
+// Output
+// [null, 4, 5, 5, 8, 8]
+
+// Explanation
+// KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]);
+// kthLargest.add(3);   // return 4
+// kthLargest.add(5);   // return 5
+// kthLargest.add(10);  // return 5
+// kthLargest.add(9);   // return 8
+// kthLargest.add(4);   // return 8
+ 
+
+// Constraints:
+
+// 1 <= k <= 104
+// 0 <= nums.length <= 104
+// -104 <= nums[i] <= 104
+// -104 <= val <= 104
+// At most 104 calls will be made to add.
+// It is guaranteed that there will be at least k elements in the array when you search for the kth element.
+
+class MedianFinder {
+    private PriorityQueue<Integer> minHeap = new PriorityQueue<>(Collections.reverseOrder());
+    private PriorityQueue<Integer> maxHeap = new PriorityQueue<>();
+    public MedianFinder() {        
+    }    
+    public void addNum(int num) {
+        if(minHeap.isEmpty() || minHeap.peek() > num) minHeap.offer(num);
+        else maxHeap.offer(num);
+        if(minHeap.size() > maxHeap.size() + 1){
+            maxHeap.offer(minHeap.poll());
+        }
+        else if(maxHeap.size() > minHeap.size() + 1){
+            minHeap.offer(maxHeap.poll());
+        }
+    }
+    
+    public double findMedian() {
+        if(minHeap.size() == maxHeap.size()) return maxHeap.size() == 0 ? 0 : (minHeap.peek() + maxHeap.peek()) / 2.0;
+        else return minHeap.size() > maxHeap.size() ? minHeap.peek() : maxHeap.peek();
+    }
+}
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * MedianFinder obj = new MedianFinder();
+ * obj.addNum(num);
+ * double param_2 = obj.findMedian();
+ */