Course Schedule

Shortest Path in Binary Matrix

Author: nlohia-godaddy

src/main/java/leetcode/medium/CourseSchedule.java

@@ -0,0 +1,40 @@
+package leetcode.medium;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class CourseSchedule {
+
+  // evaluate using BFS
+  boolean canFinish(int numCourses, int[][] prerequisites) {
+    List<List<Integer>> graph = new ArrayList<>();
+    int[] inDegree = new int[numCourses];
+    for (int i = 0; i < numCourses; i++)
+      graph.add(new ArrayList<>());
+
+
+    for (int[] pre : prerequisites) {
+      graph.get(pre[1]).add(pre[0]);
+      inDegree[pre[0]]++;
+    }
+
+    Queue<Integer> queue = new LinkedList<>();
+    for (int i = 0; i < numCourses; i++)
+      if (inDegree[i] == 0)
+        queue.offer(i);
+
+    int count = 0;
+    while (!queue.isEmpty()) {
+      int curr = queue.poll();
+      count++;
+      for (int next : graph.get(curr)) {
+        inDegree[next]--;
+        if (inDegree[next] == 0) queue.offer(next);
+      }
+    }
+    return count == numCourses;
+  }
+
+}

src/main/java/leetcode/medium/ShortestPathInBinaryMatrix.java

@@ -0,0 +1,38 @@
+package leetcode.medium;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class ShortestPathInBinaryMatrix {
+
+  int shortestPathBinaryMatrix(int[][] grid) {
+    int n = grid.length;
+
+    if (grid[0][0] != 0 || grid[n - 1][n - 1] != 0)
+      return -1;
+
+    int[][] dirs = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
+
+    Queue<int[]> queue = new LinkedList<>();
+
+    queue.offer(new int[]{0, 0, 1}); // row, col, path length
+
+    boolean[][] visited = new boolean[n][n];
+    visited[0][0] = true;
+    while (!queue.isEmpty()) {
+      int[] curr = queue.poll();
+      int r = curr[0], c = curr[1], len = curr[2];
+      if (r == n - 1 && c == n - 1) return len;
+      for (int[] d : dirs) {
+        int nr = r + d[0], nc = c + d[1];
+        if (nr >= 0 && nr < n && nc >= 0 && nc < n && grid[nr][nc] == 0 && !visited[nr][nc]) {
+          queue.offer(new int[]{nr, nc, len + 1});
+          visited[nr][nc] = true;
+        }
+      }
+    }
+
+    return -1;
+  }
+
+}

src/test/java/leetcode/medium/CourseScheduleTest.java

@@ -0,0 +1,35 @@
+package leetcode.medium;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CourseScheduleTest {
+
+  private final CourseSchedule courseSchedule;
+
+  CourseScheduleTest() {
+    courseSchedule = new CourseSchedule();
+  }
+
+  @Test
+  void testCanFinish1() {
+    int numCourses = 2;
+    int[][] prerequisites = {{1, 0}};
+    assertTrue(courseSchedule.canFinish(numCourses, prerequisites));
+  }
+
+  @Test
+  void testCanFinish2() {
+    int numCourses = 2;
+    int[][] prerequisites = {{1, 0}, {0, 1}};
+    assertFalse(courseSchedule.canFinish(numCourses, prerequisites));
+  }
+
+  @Test
+  void testCanFinish3() {
+    int numCourses = 3;
+    int[][] prerequisites = {{0, 1}, {0, 2}, {1, 2}};
+    assertTrue(courseSchedule.canFinish(numCourses, prerequisites));
+  }
+}

src/test/java/leetcode/medium/ShortestPathInBinaryMatrixTest.java

@@ -0,0 +1,33 @@
+package leetcode.medium;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ShortestPathInBinaryMatrixTest {
+
+  private final ShortestPathInBinaryMatrix shortestPathInBinaryMatrix;
+
+  ShortestPathInBinaryMatrixTest() {
+    shortestPathInBinaryMatrix = new ShortestPathInBinaryMatrix();
+  }
+
+  @Test
+  void testShortestPathBinaryMatrix1() {
+    int[][] grid = {
+      {0, 1},
+      {1, 0}
+    };
+    assertEquals(2, shortestPathInBinaryMatrix.shortestPathBinaryMatrix(grid));
+  }
+
+  @Test
+  void testShortestPathBinaryMatrix2() {
+    int[][] grid = {
+      {0, 0, 0},
+      {1, 1, 0},
+      {1, 1, 0}
+    };
+    assertEquals(4, shortestPathInBinaryMatrix.shortestPathBinaryMatrix(grid));
+  }
+}