LIVE_YOUTUBE - graphs and dp problem

Author: rachitiitr

LeetCode/1306.jump-game3.cpp

@@ -0,0 +1,26 @@
+class Solution {
+    vector<int> nums;
+    set<int> s; // what all indices are there in recursion stack
+    
+    bool isPossible(int cur) { // can we reach a zero from cur index
+        if (s.find(cur) != s.end()) {
+            return false; // we detected a cycle / deadlock
+        }
+        if(0 <= cur && cur < nums.size()) {
+            if(nums[cur] == 0) return true;
+            s.insert(cur);
+            bool ans = false;
+            if (isPossible(cur + nums[cur])) ans = true;
+            else if (isPossible(cur - nums[cur])) ans = true;
+            s.erase(cur);
+            return ans;
+        }
+        return false;
+    }
+public:
+    bool canReach(vector<int>& arr, int start) {
+        //dp[i] <-- is it possible to reach a zero from i
+        nums = arr;
+        return isPossible(start);
+    }
+};

LeetCode/542.01-matrix.cpp

@@ -0,0 +1,63 @@
+using loc = pair<int, int>;
+int dx[] = {1, -1, 0, 0};
+int dy[] = {0, 0, 1, -1};
+class Solution {
+public:
+    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {
+        int n = mat.size(), m = mat[0].size();
+        
+        vector<vector<int>> dis(n, vector<int>(m, INT_MAX));
+        // dis[i][j] = nearest distance (i, j) to nearest 0
+        
+        queue<loc> q;
+        for(int i = 0; i < n; i++) {
+            for(int j = 0; j < m; j++) {
+                if (mat[i][j] == 0) {
+                    q.push({i, j});
+                    dis[i][j] = 0;
+                }
+            }
+        }
+        
+        while(!q.empty()) {
+            // loc cur = q.front(); 
+            // int x = cur.first, y = cur.second;
+            auto [x, y] = q.front(); // current loc in mat, structured binding in C++
+            q.pop();
+            // (2,3) -> (1, 3) up, (3, 3) down, +1 -1 on the columns as well
+            for(int k = 0; k < 4; k++) {
+                int nx = x + dx[k], ny = y + dy[k];
+                if (0 <= nx && nx < n && 0 <= ny && ny < m) {
+                    // valid neighbour
+                    if (dis[nx][ny] == INT_MAX) {
+                        dis[nx][ny] = 1 + dis[x][y];
+                        q.push({nx, ny});
+                    }
+                }
+            }
+        }
+        
+        return dis;
+    }
+};
+
+/*
+// BFS gives the shortest path in unweighted graphs
+
+n * m <--- 0s and 1s
+    
+    for every 1:
+        compute the smallest distance to 0
+            
+dis[i][j] = 0 where mat[i][j] = 0
+            
+queue<> Q = {(i,j)} where mat[i][j] = 0;
+
+cur = Q.front();
+
+for(nei in neighbors(cur)) {
+    dis[nei] = 1 + dis[cur] if nei is not alreaady in queue
+}
+
+*/
+