Added Union Find, Graph and String problems

Author: devangi2000

Graphs/NumberofOperationstoMakeNetworkConnected1319.cpp

@@ -0,0 +1,72 @@
+// There are n computers numbered from 0 to n - 1 connected by ethernet cables connections forming a network where connections[i] = [ai, bi] represents a connection between computers ai and bi. Any computer can reach any other computer directly or indirectly through the network.
+
+// You are given an initial computer network connections. You can extract certain cables between two directly connected computers, and place them between any pair of disconnected computers to make them directly connected.
+
+// Return the minimum number of times you need to do this in order to make all the computers connected. If it is not possible, return -1.
+
+ 
+
+// Example 1:
+
+
+// Input: n = 4, connections = [[0,1],[0,2],[1,2]]
+// Output: 1
+// Explanation: Remove cable between computer 1 and 2 and place between computers 1 and 3.
+// Example 2:
+
+
+// Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2],[1,3]]
+// Output: 2
+// Example 3:
+
+// Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2]]
+// Output: -1
+// Explanation: There are not enough cables.
+ 
+
+// Constraints:
+
+// 1 <= n <= 105
+// 1 <= connections.length <= min(n * (n - 1) / 2, 105)
+// connections[i].length == 2
+// 0 <= ai, bi < n
+// ai != bi
+// There are no repeated connections.
+// No two computers are connected by more than one cable.
+
+class Solution {
+public:
+    int components = 0;
+    
+    void dfs(vector<vector<int>> &graph, vector<bool> &visited, int node){
+        if(visited[node])
+            return;
+        visited[node] = 1;
+        for(int child: graph[node]){
+            if(!visited[child])
+                dfs(graph, visited, child);
+        }
+    }
+    
+    int makeConnected(int n, vector<vector<int>>& connections) {
+        vector<bool> visited(n, 0);
+        vector<vector<int>> graph(n+1);
+        int edges = 0;
+        for(auto edge : connections){
+            graph[edge[0]].push_back(edge[1]);
+            graph[edge[1]].push_back(edge[0]);
+            edges++;
+        }
+        if(edges < n-1) return -1;
+        for(int i = 0; i < n; i++){
+            if(!visited[i]){
+                components++;
+                dfs(graph, visited, i);
+            }
+        }
+        int redundant = edges - ((components - 1) - (n - 1));
+        if(redundant >= (components - 1))
+            return components - 1;
+        return -1;
+    }
+};

Graphs/NumberofOperationstoMakeNetworkConnected1319.java

@@ -0,0 +1,73 @@
+// There are n computers numbered from 0 to n - 1 connected by ethernet cables connections forming a network where connections[i] = [ai, bi] represents a connection between computers ai and bi. Any computer can reach any other computer directly or indirectly through the network.
+
+// You are given an initial computer network connections. You can extract certain cables between two directly connected computers, and place them between any pair of disconnected computers to make them directly connected.
+
+// Return the minimum number of times you need to do this in order to make all the computers connected. If it is not possible, return -1.
+
+ 
+
+// Example 1:
+
+
+// Input: n = 4, connections = [[0,1],[0,2],[1,2]]
+// Output: 1
+// Explanation: Remove cable between computer 1 and 2 and place between computers 1 and 3.
+// Example 2:
+
+
+// Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2],[1,3]]
+// Output: 2
+// Example 3:
+
+// Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2]]
+// Output: -1
+// Explanation: There are not enough cables.
+ 
+
+// Constraints:
+
+// 1 <= n <= 105
+// 1 <= connections.length <= min(n * (n - 1) / 2, 105)
+// connections[i].length == 2
+// 0 <= ai, bi < n
+// ai != bi
+// There are no repeated connections.
+// No two computers are connected by more than one cable.
+
+class Solution {
+    public int components = 0, edges = 0;
+    
+    public void dfs(ArrayList<Integer>[] graph, boolean[] visited, int node){
+        if(visited[node] == true) return;
+        visited[node] = true;
+        for(int child : graph[node]){
+            if(visited[child] == false)
+                dfs(graph, visited, child);
+        }
+    }
+    
+    public int makeConnected(int n, int[][] connections) {
+        ArrayList<Integer>[] graph = new ArrayList[n+1];
+        boolean[] visited = new boolean[n];
+        Arrays.fill(visited, false);
+        for(int i = 0; i < n; i++)
+            graph[i] = new ArrayList<Integer>();
+        for(int[] edge : connections){
+            graph[edge[0]].add(edge[1]);
+            graph[edge[1]].add(edge[0]);
+            edges++;
+        }
+        if(edges < n-1)
+            return -1;
+        for(int i = 0; i < n; i++){
+            if(visited[i] == false){
+                components++;
+                dfs(graph, visited, i);
+            }
+        }
+        int redundant = edges - ((components - 1) - (n - 1));
+        if(redundant >= (components - 1))
+            return components - 1;
+        return -1;
+    }
+}

Sliding-Window/SubarrayProductLessThanK713.cpp

@@ -0,0 +1,40 @@
+// Given an array of integers nums and an integer k, return the number of contiguous subarrays where the product of all the elements in the subarray is strictly less than k.
+
+ 
+
+// Example 1:
+
+// Input: nums = [10,5,2,6], k = 100
+// Output: 8
+// Explanation: The 8 subarrays that have product less than 100 are:
+// [10], [5], [2], [6], [10, 5], [5, 2], [2, 6], [5, 2, 6]
+// Note that [10, 5, 2] is not included as the product of 100 is not strictly less than k.
+// Example 2:
+
+// Input: nums = [1,2,3], k = 0
+// Output: 0
+ 
+
+// Constraints:
+
+// 1 <= nums.length <= 3 * 104
+// 1 <= nums[i] <= 1000
+// 0 <= k <= 106
+
+class Solution {
+public:
+    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
+        if(k<=1) return 0;
+        int left = 0, right = 0, prod = 1, result = 0;
+        while(right<nums.size()){
+            prod *= nums[right];
+            while(prod>=k){
+                prod /= nums[left];
+                left++;
+            }
+            result += right-left+1;
+            right++;
+        }
+        return result;
+    }
+};

Sliding-Window/SubarrayProductLessThanK713.java

@@ -0,0 +1,39 @@
+// Given an array of integers nums and an integer k, return the number of contiguous subarrays where the product of all the elements in the subarray is strictly less than k.
+
+ 
+
+// Example 1:
+
+// Input: nums = [10,5,2,6], k = 100
+// Output: 8
+// Explanation: The 8 subarrays that have product less than 100 are:
+// [10], [5], [2], [6], [10, 5], [5, 2], [2, 6], [5, 2, 6]
+// Note that [10, 5, 2] is not included as the product of 100 is not strictly less than k.
+// Example 2:
+
+// Input: nums = [1,2,3], k = 0
+// Output: 0
+ 
+
+// Constraints:
+
+// 1 <= nums.length <= 3 * 104
+// 1 <= nums[i] <= 1000
+// 0 <= k <= 106
+
+class Solution {
+    public int numSubarrayProductLessThanK(int[] nums, int k) {
+        int n = nums.length, left = 0, right = 0, pro = 1, count = 0;
+        if(k <= 1) return 0;
+        while(right < n){
+            pro *= nums[right];
+            while(pro >= k){
+                pro /= nums[left++];
+            }
+            count += right - left + 1;
+            right++;
+        }
+        return count;
+    }
+}
+

Strings/BackSpaceStringCompare844.cpp

@@ -0,0 +1,71 @@
+// Given two strings s and t, return true if they are equal when both are typed into empty text editors. '#' means a backspace character.
+
+// Note that after backspacing an empty text, the text will continue empty.
+
+ 
+
+// Example 1:
+
+// Input: s = "ab#c", t = "ad#c"
+// Output: true
+// Explanation: Both s and t become "ac".
+// Example 2:
+
+// Input: s = "ab##", t = "c#d#"
+// Output: true
+// Explanation: Both s and t become "".
+// Example 3:
+
+// Input: s = "a#c", t = "b"
+// Output: false
+// Explanation: s becomes "c" while t becomes "b".
+ 
+
+// Constraints:
+
+// 1 <= s.length, t.length <= 200
+// s and t only contain lowercase letters and '#' characters.
+
+class Solution {
+public:
+    string getString(string s){
+        int count = 0, i = 0, j = s.size() - 1;
+        string res = "";
+        while(j >= 0){
+            if(s[j] == '#'){
+                count++; j--;
+            }
+            else{
+                if(count == 0)
+                    res += s[j--];
+                else{
+                    count--;
+                    j--;
+                }
+            }
+        }
+        return res;
+    }
+    
+    bool backspaceCompare(string s, string t) {
+        return getString(s) == getString(t);
+    }
+};
+
+// Stack
+class Solution {
+public:
+    stack<char> getString(string s){
+        stack<char> st;
+        for(char c : s){
+            if(c != '#')
+                st.push(c);
+            else if(!st.empty()) st.pop();
+        }
+        return st;
+    }
+    
+    bool backspaceCompare(string s, string t) {
+        return getString(s) == getString(t);
+    }
+};

Strings/BackSpaceStringCompare844.java

@@ -0,0 +1,70 @@
+// Given two strings s and t, return true if they are equal when both are typed into empty text editors. '#' means a backspace character.
+
+// Note that after backspacing an empty text, the text will continue empty.
+
+ 
+
+// Example 1:
+
+// Input: s = "ab#c", t = "ad#c"
+// Output: true
+// Explanation: Both s and t become "ac".
+// Example 2:
+
+// Input: s = "ab##", t = "c#d#"
+// Output: true
+// Explanation: Both s and t become "".
+// Example 3:
+
+// Input: s = "a#c", t = "b"
+// Output: false
+// Explanation: s becomes "c" while t becomes "b".
+ 
+
+// Constraints:
+
+// 1 <= s.length, t.length <= 200
+// s and t only contain lowercase letters and '#' characters.
+
+class Solution {
+public:
+    string getString(string s){
+        int count = 0, i = 0, j = s.size() - 1;
+        string res = "";
+        while(j >= 0){
+            if(s[j] == '#'){
+                count++; j--;
+            }
+            else{
+                if(count == 0)
+                    res += s[j--];
+                else{
+                    count--;
+                    j--;
+                }
+            }
+        }
+        return res;
+    }
+    
+    bool backspaceCompare(string s, string t) {
+        return getString(s) == getString(t);
+    }
+};
+
+// Stack
+class Solution {
+    public Stack<Character> getString(String s){
+        Stack<Character> st = new Stack<>();
+        for(Character c : s.toCharArray()){
+            if(c != '#')
+                st.push(c);
+            else if(!st.empty()) st.pop();
+        }
+        return st;
+    }
+    
+    public boolean backspaceCompare(String s, String t) {
+        return getString(s).equals(getString(t));
+    }
+}