[chjung99] WEEK 07 solutions

decode-ways/chjung99.java

@@ -0,0 +1,41 @@
+class Solution {
+    int[] numOfWays = new int[101];
+
+    public int numDecodings(String s) {
+        return dfs(s, 0);
+    }
+
+    public int dfs(String s, int cur) {
+        if (cur == s.length()) {
+            return 1;
+        }
+
+        int cnt = 0;
+
+        if (cur + 1 <= s.length() && isDecodable(s.substring(cur, cur + 1))){
+            if (numOfWays[cur + 1] == 0){
+                numOfWays[cur + 1] = dfs(s, cur + 1);
+            }
+            cnt += numOfWays[cur + 1];
+        }
+
+        if (cur + 2 <= s.length()&& isDecodable(s.substring(cur, cur + 2))) {
+            if (numOfWays[cur + 2] == 0){
+                numOfWays[cur + 2] = dfs(s, cur + 2);
+            }
+            cnt += numOfWays[cur + 2];
+        }
+
+        return cnt;
+    }
+
+    public boolean isDecodable(String s) {
+        if (s.startsWith("0")){
+            return false;
+        }
+        int digit = Integer.valueOf(s);
+        return (digit >= 1 && digit <= 26);
+    }
+}
+
+

insert-interval/chjung99.java

@@ -0,0 +1,65 @@
+class Solution {
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        Deque<Interval> deque = new ArrayDeque<>();
+        List<Interval> ordered = new ArrayList<>();
+        List<Interval> merged = new ArrayList<>();
+
+        for (int i = 0; i < intervals.length; i++){
+            ordered.add(new Interval(intervals[i]));
+        }
+
+        ordered.add(new Interval(newInterval));
+        Collections.sort(ordered);
+
+        Interval cur;
+        Interval next;
+
+        int curIdx = 0;
+        deque.add(ordered.get(0));
+
+        while (curIdx < ordered.size()){
+            cur = deque.removeLast();
+
+            if (curIdx + 1 < ordered.size()){
+                next = ordered.get(curIdx + 1);
+                if (next.start <= cur.end){ // merge
+                    Interval mergedInterval = new Interval( new int[]{
+                            Math.min(cur.start, next.start), Math.max(cur.end, next.end)
+                    });
+                    deque.addLast(mergedInterval);
+                } else {
+                    deque.addLast(cur);
+                    deque.addLast(next);
+                }
+
+            } else {
+                deque.addLast(cur);
+            }
+            curIdx ++;
+        }
+        int[][] answer = new int[deque.size()][2];
+        int idx = 0;
+        while (!deque.isEmpty()){
+            answer[idx++] = deque.removeFirst().raw;
+        }
+        return answer;
+    }
+    class Interval implements Comparable<Interval>{
+        int[] raw;
+        int start;
+        int end;
+
+        public Interval(int[] raw){
+            this.raw = raw;
+            this.start = raw[0];
+            this.end = raw[1];
+        }
+
+        @Override
+        public int compareTo(Interval o){
+            return Integer.compare(this.start, o.start);
+        }
+    }
+}
+
+

set-matrix-zeroes/chjung99.java

@@ -0,0 +1,42 @@
+class Solution {
+    int m;
+    int n;
+    public void setZeroes(int[][] matrix) {
+        m = matrix.length;
+        n = matrix[0].length;
+
+        Set<Integer> rows = new HashSet<>();
+        Set<Integer> cols = new HashSet<>();
+
+        for (int i = 0; i < m; i++){
+            for (int j = 0; j < n; j++){
+                if (matrix[i][j] == 0){
+                    rows.add(i);
+                    cols.add(j);
+                }
+            }
+        }
+
+        for (int row : rows) {
+            setZeroRow(row, matrix);
+        }
+
+        for (int col : cols) {
+            setZeroCol(col, matrix);
+        }
+    }
+
+    public void setZeroCol(int col, int[][] matrix){
+        for (int i = 0; i < m; i++) {
+            matrix[i][col] = 0;
+        }
+    }
+
+    public void setZeroRow(int row, int[][] matrix){
+        for (int i = 0; i < n; i++) {
+            matrix[row][i] = 0;
+        }
+    }
+}
+
+

unique-paths/chjung99.java

@@ -0,0 +1,18 @@
+class Solution {
+
+    public int uniquePaths(int m, int n) {
+        int[][] dp = new int[m+1][n+1]; // (1,1) ~ (m, n)
+
+        for (int i = 1; i <= n; i++){
+            dp[1][i] = 1;
+        }
+        for (int i = 2; i <= m; i++){
+            for (int j = 1; j <= n; j++){
+                dp[i][j] = dp[i][j-1] + dp[i-1][j];
+            }
+        }
+        return dp[m][n];
+    }
+}
+
+

word-search/chjung99.java

@@ -0,0 +1,50 @@
+class Solution {
+    int m, n;
+    int[] dx = new int[]{0, 1, 0, -1};
+    int[] dy = new int[]{1, 0, -1, 0};
+    boolean answer = false;
+    boolean[][] visit;
+
+    public boolean exist(char[][] board, String word) {
+        m = board.length;
+        n = board[0].length;
+        visit = new boolean[m][n];
+
+        for (int i = 0; i < m; i++){
+            for (int j = 0; j < n; j++){
+                if (board[i][j] == word.charAt(0)){
+                    visit[i][j] = true;
+                    dfs(i, j, board, word, 0);
+                    visit[i][j] = false;
+                }
+            }
+        }
+        return answer;
+    }
+
+    public void dfs(int cx, int cy, char[][] board, String word, int depth){
+        if (depth == word.length()-1){
+            answer = true;
+            return;
+        }
+
+        for (int i = 0; i < 4; i++){
+            int nx = cx + dx[i];
+            int ny = cy + dy[i];
+            int nextDepth = depth + 1;
+
+            if (outOfRange(nx, ny)||visit[nx][ny]) continue;
+            if (board[nx][ny] == word.charAt(nextDepth)){
+                visit[nx][ny] = true;
+                dfs(nx, ny, board, word, nextDepth);
+                visit[nx][ny] = false;
+            }
+        }
+    }
+
+    public boolean outOfRange(int x, int y){
+        return (x < 0 || x >= m) || (y < 0 || y >= n);
+    }
+}
+
+