[chjung99] WEEK 06 solutions

jump-game/chjung99.java

@@ -0,0 +1,38 @@
+class Solution {
+    boolean isArrived;
+    int SIZE;
+
+    public boolean canJump(int[] nums) {
+        isArrived = false;
+        SIZE = nums.length;
+
+        bfs(nums, 0);
+
+        return isArrived;
+    }
+
+    public void bfs(int[] nums, int x) {
+        Queue<Integer> q = new ArrayDeque<>();
+        q.add(x);
+        boolean[] visit = new boolean[SIZE];
+        visit[x] = true;
+
+        int curX;
+        int nextX;
+
+        while (!q.isEmpty()){
+            curX = q.poll();
+            isArrived = (curX + 1) == SIZE;
+            if (isArrived) return;
+
+            for (int dx = 1; dx <= nums[curX]; dx++){
+                nextX = curX + dx;
+                if (nextX >= SIZE || visit[nextX]) continue;
+                q.add(nextX);
+                visit[nextX] = true;
+            }
+        }
+    }
+}
+
+

maximum-subarray/chjung99.java

@@ -0,0 +1,25 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int n = nums.length;
+        int[] sum = new int[n];
+
+        int minValue = 0;
+        int answer = nums[0];
+
+        for (int i = 0; i < n; i++){
+            if (i == 0) sum[i] = nums[i];
+            else sum[i] = sum[i-1] + nums[i];
+        }
+
+        for (int i = 0 ; i < n; i++){
+            answer = Math.max(answer, sum[i] - minValue);
+            if (minValue > sum[i]){
+                minValue = sum[i];
+            }
+        }
+        return answer;
+
+    }
+}
+
+

merge-intervals/chjung99.java

@@ -0,0 +1,49 @@
+class Solution {
+    public int[][] merge(int[][] intervals) {
+        //sort by start_i
+        List<Interval> ordered = new ArrayList<>();
+        for (int i = 0; i < intervals.length; i++){
+            ordered.add(new Interval(intervals[i]));
+        }
+        Collections.sort(ordered);
+
+        Deque<Interval> queue = new ArrayDeque<>();
+        queue.add(ordered.get(0));
+        //merge in order
+        for (int i = 1; i < ordered.size(); i++) {
+            Interval tail = queue.removeLast();
+            Interval cur = ordered.get(i);
+
+            if (tail.end >= cur.start){
+                Interval merged = new Interval(new int[]{Math.min(tail.start, cur.start), Math.max(tail.end, cur.end)});
+                queue.add(merged);
+            } else{
+                queue.add(tail);
+                queue.add(cur);
+            }
+        }
+        int[][] answer = new int[queue.size()][2];
+        int idx = 0;
+        while (!queue.isEmpty()){
+            answer[idx++] = queue.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);
+        }
+    }
+}
+
+

rotate-image/chjung99.java

@@ -0,0 +1,22 @@
+class Solution {
+    public void rotate(int[][] matrix) {
+        int tmp;
+        int n = matrix.length;
+        for (int i = 0; i < n; i++){
+            for (int j = i; j < n; j++){
+                tmp = matrix[j][i];
+                matrix[j][i] = matrix[i][j];
+                matrix[i][j] = tmp;
+            }
+        }
+        for (int i = 0; i < n; i++){
+            for (int j =0; j < (int)(n/2); j++){
+                tmp = matrix[i][n-1-j];
+                matrix[i][n-1-j] = matrix[i][j];
+                matrix[i][j] = tmp;
+            }
+        }
+    }
+}
+
+

spiral-matrix/chjung99.java

@@ -0,0 +1,68 @@
+class Solution {
+    // right, down, left, up
+    int[] dx = {0, 1, 0, -1};
+    int[] dy = {1, 0, -1, 0};
+    boolean[][] visit;
+
+    int m;
+    int n;
+    public List<Integer> spiralOrder(int[][] matrix) {
+        m = matrix.length;
+        n = matrix[0].length;
+        visit = new boolean[m][n];
+        return bfs(matrix);
+    }
+
+    public boolean outOfRange(int x, int y){
+        return ((x < 0 || x >= m) || (y < 0 || y >= n));
+    }
+
+    public List<Integer> bfs(int[][] matrix) {
+        List<Integer> spiral = new ArrayList<>();
+
+        Queue<Point> q = new ArrayDeque<>();
+
+        int startX = 0;
+        int startY = 0;
+        int startDir = 0;
+
+        q.add(new Point(startX, startY, startDir));
+        visit[startX][startY] = true;
+
+        while (!q.isEmpty()){
+            Point cur = q.poll();
+            spiral.add(matrix[cur.x][cur.y]);
+
+            int nextX = cur.x + dx[cur.dir];
+            int nextY = cur.y + dy[cur.dir];
+            int nextDir = cur.dir;
+
+            if (outOfRange(nextX, nextY) || visit[nextX][nextY]) {
+                nextDir = (nextDir + 1) % 4;
+            }
+
+            nextX = cur.x + dx[nextDir];
+            nextY = cur.y + dy[nextDir];
+
+            if (!outOfRange(nextX, nextY) && !visit[nextX][nextY]){
+                q.add(new Point(nextX, nextY, nextDir));
+                visit[nextX][nextY] = true;
+            }
+        }
+        return spiral;
+    }
+
+    class Point{
+        int x;
+        int y;
+        int dir;
+        public Point(int x, int y, int dir){
+            this.x = x;
+            this.y = y;
+            this.dir = dir;
+        }
+    }
+
+}
+
+