Day 7 Shortest path maze problem

Author: mandliya

README.md

@@ -6,8 +6,8 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 142 |
-| Current Streak | 6 days |
+| Total Problems | 143 |
+| Current Streak | 7 days |
 | Longest Streak | 91 ( August 17, 2015 - November 15, 2015 ) |
 
 </center>
@@ -219,6 +219,7 @@ Include contains single header implementation of data structures and some algori
 | Count the number of prime numbers less than a non-negative number, n.| [countPrimes.cpp](leet_code_problems/countPrimes.cpp)|
 | Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers. Ensure that numbers within the set are sorted in ascending order. Example : for k = 3, n = 9 result would be [[1,2,6], [1,3,5], [2,3,4]], similarly for k = 3, n = 7, result would be [[1,2,4]]. | [combinationSum3.cpp](leet_code_problems/combinationSum3.cpp) |
 | Given a non-negative integer num, repeatedly add all its digits until the result has only one digit. For example: Given num = 38, the process is like: 3 + 8 = 11, 1 + 1 = 2. Since 2 has only one digit, return it. Follow up: Could you do it without any loop/recursion in O(1) runtime?| [addDigits.cpp](leet_code_problems/addDigits.cpp)|
+|Given a matrix with cell values 0 or 1. Find the length of the shortest path from (a1, b1) to (a2, b2), such that path can only be constructed through cells which have value 1 and you can only travel in 4 possible directions, i.e. left, right, up and down.|[shortest_path_maze.cpp](leet_code_problems/shortest_path_maze.cpp)|
 
 
 

leet_code_problems/shortest_path_maze.cpp

@@ -0,0 +1,141 @@
+/*
+ * Given a matrix with cell values 0 or 1. Find the length of the shortest path from (a1, b1)
+ * to (a2, b2), such that:
+ * Path can only be constructed through cells which have value 1.
+ * You can only travel in 4 possible directions, i.e. left, right, up and down.
+ *
+ * For example: Given matrix:
+ * Input:
+ * mat[ROW][COL]  = {{1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
+ *                   {1, 0, 1, 0, 1, 1, 1, 0, 1, 1 },
+ *                   {1, 1, 1, 0, 1, 1, 0, 1, 0, 1 },
+ *                   {0, 0, 0, 0, 1, 0, 0, 0, 0, 1 },
+ *                   {1, 1, 1, 0, 1, 1, 1, 0, 1, 0 },
+ *                   {1, 0, 1, 1, 1, 1, 0, 1, 0, 0 },
+ *                   {1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
+ *                   {1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
+ *                   {1, 1, 0, 0, 0, 0, 1, 0, 0, 1 }};
+ * Source = {0, 0};
+ * Destination = {3, 4};
+ * Output:
+ * Shortest Path is 11
+ *
+ * We will use breadth first search, we start from source cell (and distance 0)
+ * and explore neighbors in all possible directions, and keep adding
+ * distance from source node for each cell, so for a cell we reach, 
+ * its shortest path = shortest path of parent + 1. We stop when we have reached
+ * destination. If we have explored all possible valid cells from source cell,
+ * we return false, i.e. we do not have valid path from source.
+ */
+
+
+#include <iostream>
+#include <queue>
+#include <limits>
+
+struct Point
+{
+    int x;
+    int y;
+};
+
+struct Node
+{
+    Point point;
+    int distance;
+};
+
+bool valid(const std::vector<std::vector<int>>& matrix, int x, int y)
+{
+    return (x >= 0 && x < matrix[0].size() && y >= 0 && y < matrix.size());
+}
+
+int shortestPath(const std::vector<std::vector<int>>& matrix,
+    const Point& source,
+    const Point& destination)
+{
+    // An auxillary matrix to keep track of visited points
+    // initially all cells are marked unvisited.
+    //
+    std::vector<std::vector<bool>> visited(
+       matrix.size(),
+       std::vector<bool>(matrix[0].size(), false));
+
+    // Possible moves from a cell.
+    //
+    std::vector<int> row = {-1, 0, 0, 1};
+    std::vector<int> col = {0, -1, 1, 0};
+    
+    std::queue<Node> nodeQueue;
+
+    // mark the source cell visited and push it to queue.
+    //
+    visited[source.x][source.y] = true;
+    nodeQueue.push({source.x, source.y, 0});
+
+    while (!nodeQueue.empty())
+    {
+        // pop the front of the queue.
+        Node current = nodeQueue.front();
+        nodeQueue.pop();
+
+        Point point = current.point;
+
+        // if we have reached destination return distance.
+        if (point.x == destination.x && point.y == destination.y)
+        {
+            return current.distance;
+        }
+
+        for (int i = 0; i < 4; ++i)
+        {
+            int r = point.x + row[i];
+            int c = point.y + col[i];
+
+            if (valid(matrix, r, c) &&
+                matrix[r][c] && !visited[r][c])
+            {
+                visited[r][c] = true;
+                Node adjNode = {r, c, current.distance + 1};
+                nodeQueue.push(adjNode);
+            }
+        }
+    }
+    return std::numeric_limits<int>::max();
+}
+
+int main()
+{
+    const std::vector<std::vector<int>> matrix = 
+        {{ 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
+         { 1, 0, 1, 0, 1, 1, 1, 0, 1, 1 },
+         { 1, 1, 1, 0, 1, 1, 0, 1, 0, 1 },
+         { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 },
+         { 1, 1, 1, 0, 1, 1, 1, 0, 1, 0 },
+         { 1, 0, 1, 1, 1, 1, 0, 1, 0, 0 },
+         { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
+         { 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
+         { 1, 1, 0, 0, 0, 0, 1, 0, 0, 1 }};
+    
+    Point source = {0, 0};
+    Point destination = {3, 4};
+    int distance = shortestPath(matrix, source, destination);
+    if (distance != 
+        std::numeric_limits<int>::max())
+    {
+        std::cout << "The distance between ("
+            << source.x << ", " << source.y
+            << ") and destination (" << destination.x
+            << ", " << destination.y << ") is "
+            << distance << std::endl;
+    }
+    else
+    {
+        std::cout << "The path does not exist between ("
+            << source.x << ", " << source.y
+            << ") and destination (" << destination.x
+            << ", " << destination.y << ") is "
+            << distance << std::endl;
+    }
+    return 0;
+}