update

Author: rchen102

Java/leetcode 10.java

@@ -0,0 +1,35 @@
+class Solution {
+    public boolean isMatch(String s, String p) {
+        if (s == null || p == null) return s == p;
+        // dp table
+        int len1 = s.length(), len2 = p.length();
+        boolean[][] dp = new boolean[len1+1][len2+1];
+        // base case
+        dp[0][0] = true;
+        for (int j = 0; j < len2; j++) {
+            if (p.charAt(j) == '*' && dp[0][j-1]) {
+                dp[0][j+1] = true;
+            }
+        }
+        
+        // dp 推导
+        for (int i = 1; i <= len1; i++) {
+            for (int j = 1; j <= len2; j++) {
+                if (s.charAt(i-1) == p.charAt(j-1) || p.charAt(j-1) == '.') {
+                    dp[i][j] = dp[i-1][j-1];
+                }
+                if (p.charAt(j-1) == '*') {
+                    // 匹配 0 次
+                    if (s.charAt(i-1) != p.charAt(j-2) && p.charAt(j-2) != '.') {
+                        dp[i][j] = dp[i][j-2];
+                    }
+                    else {
+                        // 匹配 0 或 n 次
+                        dp[i][j] = dp[i-1][j] || dp[i][j-2];
+                    }
+                }
+            }
+        }
+        return dp[len1][len2];
+    }
+}

Java/leetcode 1293.java

@@ -0,0 +1,78 @@
+// Solution: bfs T: O(n) S: O(n)
+class Solution {
+    
+    class Node {
+        int row;
+        int col;
+        int step;
+        int obs;
+        
+        public Node(int row, int col, int step, int obs) {
+            this.row = row;
+            this.col = col;
+            this.step = step;
+            this.obs = obs;
+        }
+    }
+    
+    public int shortestPath(int[][] grid, int k) {
+        if (grid == null) return -1;
+        int n = grid.length;
+        if (grid[0] == null) return -1;
+        int m = grid[0].length;
+        
+        Queue<Node> queue = new LinkedList<>();
+        Node start = new Node(0, 0, 0, 0);
+        queue.offer(start);
+        
+        Node[][] visited = new Node[n][m];
+        visited[0][0] = start;
+        
+        // 移动方向
+        int[] dx = new int[]{-1, 1, 0 , 0};
+        int[] dy = new int[]{0, 0, -1, 1};
+        
+        while (!queue.isEmpty()) {
+            int sz = queue.size();
+            for (int i = 0; i < sz; i++) {
+                Node tmp = queue.poll();
+                int row = tmp.row;
+                int col = tmp.col;
+                int step = tmp.step;
+                int obs = tmp.obs;
+                if (row == n-1 && col == m-1) {
+                    return step;
+                }
+                // four direction
+                for (int j = 0; j < 4; j++) {
+                    int newRow = row + dx[j];
+                    int newCol = col + dy[j];
+                    
+                    if (!checkBoundary(newRow, newCol, n, m)) continue;
+                    int newObs = obs + (grid[newRow][newCol] == 1 ? 1 : 0);
+                    if (newObs > k) continue;
+                    Node newNode = new Node(newRow, newCol, step+1, newObs);
+                    // 第一次遍历
+                    if (visited[newRow][newCol] == null) {
+                        visited[newRow][newCol] = newNode;
+                        queue.offer(newNode);
+                    } else {
+                        // 不是第一次遍历该结点，但是新路线障碍物更少
+                        if (newObs < visited[newRow][newCol].obs) {
+                            visited[newRow][newCol] = newNode;
+                            queue.offer(newNode);
+                        }
+                    }
+                }
+            }
+        }
+        return -1;
+        
+    }
+    
+    public static boolean checkBoundary(int row, int col, int n, int m) {
+        if (row < 0 || row >= n) return false;
+        if (col < 0 || col >= m) return false;
+        return true;
+    }
+}

Java/leetcode 191.java

@@ -1,3 +1,16 @@
+public class Solution {
+    // you need to treat n as an unsigned value
+    public int hammingWeight(int n) {
+        int count = 0;
+        while (n != 0) {
+            count++;
+            n = n & (n-1);
+        }
+        return count;
+    }
+}
+
+
 //Solution1: bit manipulation T: O(1) S: O(1)
 public class Solution {
     // you need to treat n as an unsigned value