🚀 29-Jul-2022

Author: sureshmangs

CPPNotes.md

@@ -0,0 +1,86 @@
+Given a list of lowercase alphabetical strings words, 
+return the maximum sum of the lengths of two distinct words that don't share a common letter.
+
+Constraints
+
+n = 1,000 where n is the length of words
+w = 1,000 where w is the length of the longest string in words
+Example 1
+Input
+words = ["abcde", "xyz", "abdexyz", "axyz"]
+Output
+8
+Explanation
+These two words don't share any common letters ["abcde", "xyz"]
+
+
+
+
+
+
+
+
+
+
+// Brute Force (TLE)
+
+int solve(vector<string>& words) {
+    int sum = 0;
+
+    for (int i = 0; i < words.size(); i++) {
+        unordered_map <char, bool> freq;
+        for (auto &x: words[i]) freq[x] = true;
+
+        for (int j = i + 1; j < words.size(); j++) {
+            bool same = false;
+            for (auto &x: words[j]) {
+                if (freq[x]) {
+                    same = true; break;
+                }
+            }
+            if (!same) {
+                int tmpSum = words[i].length() + words[j].length();
+                sum = max(sum, tmpSum);
+            }
+        }
+    }
+    return sum;
+}
+
+
+
+
+
+
+
+
+
+// Bitmasking (Accepted)
+
+int getBitValue(string word) {
+    int value = 0;
+    for (auto &c: word) {
+        int j = (c - 'a');
+        value = value | (1 << j);
+    }
+    return value;
+}
+
+int solve(vector<string>& words) {
+    int sum = 0, n = words.size();
+    vector <int> bitRepresentation;
+
+    for (auto &word: words) {
+        bitRepresentation.push_back(getBitValue(word));
+    }
+
+    for (int i = 0; i < n; i++) {
+        for (int j = i + 1; j < n; j++) {
+            if (int(bitRepresentation[i] & bitRepresentation[j]) == 0) {
+                int tmpSum = words[i].length() + words[j].length();
+                sum = max(sum, tmpSum);
+            }
+        }
+    }
+    return sum;
+}

bit magic/Max_Character_Distinct_Words.cpp

@@ -0,0 +1,173 @@
+Given an n x n binary matrix grid, return the length of the shortest 
+clear path in the matrix. If there is no clear path, return -1.
+
+A clear path in a binary matrix is a path from the top-left cell 
+(i.e., (0, 0)) to the bottom-right cell (i.e., (n - 1, n - 1)) such that:
+
+All the visited cells of the path are 0.
+All the adjacent cells of the path are 8-directionally connected 
+(i.e., they are different and they share an edge or a corner).
+The length of a clear path is the number of visited cells of this path.
+
+ 
+
+Example 1:
+
+
+Input: grid = [[0,1],[1,0]]
+Output: 2
+Example 2:
+
+
+Input: grid = [[0,0,0],[1,1,0],[1,1,0]]
+Output: 4
+Example 3:
+
+Input: grid = [[1,0,0],[1,1,0],[1,1,0]]
+Output: -1
+ 
+
+Constraints:
+
+n == grid.length
+n == grid[i].length
+1 <= n <= 100
+grid[i][j] is 0 or 1
+
+
+
+
+
+
+
+
+
+/*
+Here DFS give TLE because we search for every path and then take min out of all that paths
+But BFS work ?? why ?
+because we do traverse in DFS manner so first time when we get target cell a[n-1][n-1] 
+then this path is always minimum as we do DFS
+
+Both solution are mentioned below
+*/
+
+
+// dfs (TLE)
+
+class Solution {
+public:
+    int shortestPath = INT_MAX;
+    vector <vector<bool>> vis;
+    vector <pair<int, int>> directions = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}, {-1, -1}, {-1, 1}, {1, 1}, {1, -1}};
+    
+    bool isValid(int i, int j, vector<vector<int>> &grid) {
+        return (i >= 0 && i < grid.size() && j >= 0 && j < grid.size() && !vis[i][j] && grid[i][j] == 0);
+    }
+    
+    void dfs(int i, int j, int path, vector<vector<int>> &grid) {
+        if (i == grid.size() - 1 && j == grid.size() - 1) {
+            path++;
+            shortestPath = min(shortestPath, path);
+            return;
+        }
+        
+        vis[i][j] = true;
+        
+        for (auto direction: directions) {
+            int x = i + direction.first;
+            int y = j + direction.second;
+            if (isValid(x, y, grid)) dfs(x, y, path + 1, grid);
+        }
+        
+        vis[i][j] = false; // backtrack
+    }
+    
+    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
+        int n = grid.size();
+        vis.resize(n, vector<bool>(n, false));
+        
+        if (grid[0][0] != 0 || grid[n - 1][n - 1] != 0) return -1; // no path possible
+        
+        dfs(0, 0, 0, grid);
+        
+        return shortestPath != INT_MAX ? shortestPath : -1;
+    }
+};
+
+
+
+
+
+
+
+
+
+// bfs
+
+class Solution {
+public:
+    int shortestPath = INT_MAX;
+    vector <vector<bool>> vis;
+    vector <pair<int, int>> directions = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}, {-1, -1}, {-1, 1}, {1, 1}, {1, -1}};
+    
+    bool isValid(int i, int j, vector<vector<int>> &grid) {
+        return (i >= 0 && i < grid.size() && j >= 0 && j < grid.size() && !vis[i][j] && grid[i][j] == 0);
+    }
+    
+    void bfs(int i, int j, int path, vector<vector<int>> &grid) {
+        queue <pair<int, int>> q;
+        
+        q.push({i, j});
+        
+        while (!q.empty()) {
+            int size = q.size();
+            path++;
+            
+            while (size--) {
+                
+                i = q.front().first;
+                j = q.front().second;
+                q.pop();
+
+                if (i == grid.size() - 1 && j == grid.size() - 1) {
+                    shortestPath = min(shortestPath, path);
+                    return;
+                }
+
+                for (auto direction: directions) {
+                    int x = i + direction.first;
+                    int y = j + direction.second;
+
+                    if (isValid(x, y, grid)) {
+                        vis[x][y] = 1; // mark visited
+                        // here we don't mark vis[i][j] as visted
+                        q.push({x, y});
+                    }
+                }
+            }
+        }
+    }
+    
+    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
+        int n = grid.size();
+        vis.resize(n, vector<bool>(n, false));
+        
+        if (grid[0][0] != 0 || grid[n - 1][n - 1] != 0) return -1; // no path possible
+        
+        bfs(0, 0, 0, grid);
+        
+        return shortestPath != INT_MAX ? shortestPath : -1;
+    }
+};
+
+
+
+
+
+
+
+
+
+// OPtimization
+// We can use the grid to make track of the visited nodes, update grid[i][j] = 1,
+// so that we don't visite it again

competitive programming/leetcode/1091. Shortest Path in Binary Matrix.cpp

@@ -0,0 +1,98 @@
+There are n servers numbered from 0 to n - 1 connected by undirected server-to-server 
+connections forming a network where connections[i] = [ai, bi] represents a connection 
+between servers ai and bi. Any server can reach other servers directly or indirectly through the network.
+
+A critical connection is a connection that, if removed, will make some servers unable to reach some other server.
+
+Return all critical connections in the network in any order.
+
+ 
+Example 1:
+
+
+Input: n = 4, connections = [[0,1],[1,2],[2,0],[1,3]]
+Output: [[1,3]]
+Explanation: [[3,1]] is also accepted.
+Example 2:
+
+Input: n = 2, connections = [[0,1]]
+Output: [[0,1]]
+ 
+
+Constraints:
+
+2 <= n <= 105
+n - 1 <= connections.length <= 105
+0 <= ai, bi <= n - 1
+ai != bi
+There are no repeated connections.
+
+
+
+
+
+
+
+
+
+
+// Approach 1: Brute Force
+// Create a graph, traverse over the edges and remove the current edge from the graph
+// and check via a dfs traversal whether all the nodes are still rechable from any node to any other
+// if not, then it's a critical connection/
+// TC -> O(E(V + E))
+
+
+
+// Approach 2:
+// TC -> O(V + E)
+
+class Solution {
+public:
+    vector <bool> visited;
+    vector <int> disc, low, parent;
+    vector<vector<int>> criticalConn;
+    int id = 0;
+    
+    void dfs(int u, vector <int> graph[]) {
+        visited[u] = true;
+        disc[u] = id;
+        low[u] = id;
+        id++;
+        
+        for (auto v: graph[u]) {
+            if (!visited[v]) {
+                parent[v] = u;
+                dfs(v, graph);
+                low[u] = min(low[u], low[v]);
+                
+                if (low[v] > disc[u]) {
+                    criticalConn.push_back({u, v});
+                }
+            } else if (v != parent[u]) {
+                low[u] = min(low[u], disc[v]);
+            }
+        }
+        
+    }
+    
+    vector<vector<int>> criticalConnections(int n, vector<vector<int>>& connections) {
+        vector <int> graph[n];
+        
+        for (auto connection: connections) {
+            graph[connection[0]].push_back(connection[1]);
+            graph[connection[1]].push_back(connection[0]);
+        }
+        
+        visited.resize(n, false);
+        disc.resize(n, 0);
+        low.resize(n, 0);
+        parent.resize(n, -1);
+        
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) dfs(i, graph);
+        }
+        
+        return criticalConn;
+    }
+};