Merge pull request neetcode-gh#3264 from adityaiiitr/adityacpp

a93a · web-flow · commit 04d441819f6f · 2024-02-06T18:51:42.000+01:00
create 1091-shortestpath-in-binary-matrix.cpp
diff --git a/cpp/0787-cheapest-flights-within-k-stops.cpp b/cpp/0787-cheapest-flights-within-k-stops.cpp
@@ -1,3 +1,40 @@
+/**
+  This function uses the Bellman-Ford algorithm to find the cheapest price from source (src) to destination (dst)
+  with at most k stops allowed. It iteratively relaxes the edges for k+1 iterations, updating the minimum
+  cost to reach each vertex. The final result is the minimum cost to reach the destination, or -1 if the
+  destination is not reachable within the given constraints.
+  
+  Space Complexity: O(n) - space used for the prices array.
+  Time Complexity: O(k * |flights|) - k iterations, processing all flights in each iteration.
+ */
+class Solution {
+public:
+    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
+        vector<int> prices(n, INT_MAX);
+        prices[src] = 0;
+
+        // Perform k+1 iterations of Bellman-Ford algorithm.
+        for (int i = 0; i < k + 1; i++) {
+            vector<int> tmpPrices(begin(prices), end(prices));
+
+            for (auto it : flights) {
+                int s = it[0];
+                int d = it[1];
+                int p = it[2];
+
+                if (prices[s] == INT_MAX) continue;
+
+                if (prices[s] + p < tmpPrices[d]) {
+                    tmpPrices[d] = prices[s] + p;
+                }
+            }
+            prices = tmpPrices;
+        }
+        return prices[dst] == INT_MAX ? -1 : prices[dst];
+    }
+};
+
+
 /*
     Given cities connected by flights [from,to,price], also given src, dst, & k:
     Return cheapest price from src to dst with at most k stops
@@ -75,4 +112,4 @@ class Solution {
         }
         return distances[dst];
     }
-};
+};
diff --git a/cpp/1091-shortest-path-in-binary-matrix.cpp b/cpp/1091-shortest-path-in-binary-matrix.cpp
@@ -0,0 +1,39 @@
+class Solution {
+public:
+    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
+        int n = grid.size();
+        if(grid[0][0]==1 || grid[n-1][n-1]==1) return -1;
+
+        // {{r,c},length}
+        queue<pair<pair<int,int>,int>> q;
+        set<pair<int,int>> visited;
+
+        q.push({{0,0},0});
+        visited.insert(make_pair(0,0));
+
+        int drow[] = {0,1,0,-1,1,-1,1,-1};
+        int dcol[] = {1,0,-1,0,1,-1,-1,1};
+
+        while(!q.empty()){
+            int row = q.front().first.first;
+            int col = q.front().first.second;
+            int len = q.front().second;
+
+            if(row == n-1 && col == n-1){
+                return len+1;
+            }
+
+            for(int i=0; i<8; i++){
+                int nrow = row + drow[i];
+                int ncol = col + dcol[i];
+
+                if(nrow>=0 && nrow<n && ncol>=0 && ncol<n && visited.find({nrow,ncol})==visited.end() && grid[nrow][ncol]==0){
+                    q.push({{nrow,ncol},len+1});
+                    visited.insert(make_pair(nrow,ncol));
+                }
+            }
+            q.pop(); 
+        }
+        return -1;
+    }
+};
