Update

Author: ex01tus

src/array/MeetingRooms.java

@@ -0,0 +1,30 @@
+package array;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * Description: https://leetcode.com/problems/meeting-rooms
+ * Difficulty: Easy
+ * Time complexity: O(nlog n)
+ * Space complexity: O(1)
+ */
+public class MeetingRooms {
+
+    public boolean canAttendMeetings(Interval[] intervals) {
+        Arrays.sort(intervals, Comparator.comparingInt(i -> i.start));
+
+        for (int i = 1; i < intervals.length; i++) {
+            if (intervals[i].start < intervals[i - 1].end) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static class Interval {
+        int start;
+        int end;
+    }
+}

src/binary/AddBinary.java

@@ -4,7 +4,7 @@
  * Description: https://leetcode.com/problems/add-binary
  * Difficulty: Easy
  * Time complexity: O(n)
- * Space complexity: O(1)
+ * Space complexity: O(n)
  */
 public class AddBinary {
 

src/heap/KClosestPointsToOrigin.java

@@ -23,19 +23,19 @@ public int[][] kClosestViaSorting(int[][] points, int k) {
      * Time complexity: O(nlog k)
      * Space complexity: O(k)
      */
-    public int[][] kClosestViaMaxHeap(int[][] points, int k) {
-        Queue<int[]> maxHeap = new PriorityQueue<>((p1, p2) -> Integer.compare(distance(p2), distance(p1)));
+    public int[][] kClosestViaMinHeap(int[][] points, int k) {
+        Queue<int[]> minHeap = new PriorityQueue<>((p1, p2) -> Integer.compare(distance(p2), distance(p1)));
 
         for (int[] point : points) {
-            maxHeap.offer(point);
-            if (maxHeap.size() > k) {
-                maxHeap.poll();
+            minHeap.offer(point);
+            if (minHeap.size() > k) {
+                minHeap.poll();
             }
         }
 
         int[][] result = new int[k][2];
         for (int i = 0; i < k; i++) {
-            result[i] = maxHeap.poll();
+            result[i] = minHeap.poll();
         }
 
         return result;

src/linked_list/AddTwoNumbers.java

@@ -0,0 +1,51 @@
+package linked_list;
+
+/**
+ * Description: https://leetcode.com/problems/add-two-numbers
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class AddTwoNumbers {
+
+    public ListNode addTwoNumbers(ListNode first, ListNode second) {
+        int carry = 0;
+        ListNode head = new ListNode();
+        ListNode current = head;
+
+        while (first != null || second != null) {
+            int sum = carry;
+            if (first != null) {
+                sum += first.val;
+                first = first.next;
+            }
+
+            if (second != null) {
+                sum += second.val;
+                second = second.next;
+            }
+
+            current.next = new ListNode(sum % 10);
+            current = current.next;
+            carry = sum / 10;
+        }
+
+        if (carry != 0) {
+            current.next = new ListNode(carry);
+        }
+
+        return head.next;
+    }
+
+    private static class ListNode {
+        ListNode next;
+        int val;
+
+        public ListNode() {
+        }
+
+        public ListNode(int val) {
+            this.val = val;
+        }
+    }
+}

src/linked_list/RemoveNthNodeFromEndOfList.java

@@ -0,0 +1,36 @@
+package linked_list;
+
+/**
+ * Description: https://leetcode.com/problems/remove-nth-node-from-end-of-list
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class RemoveNthNodeFromEndOfList {
+
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        ListNode slow = head;
+        ListNode fast = head;
+
+        for (int i = 0; i < n; i++) {
+            fast = fast.next;
+        }
+
+        if (fast == null) { // n == list.size() -> head deletion
+            return head.next;
+        }
+
+        while (fast.next != null) {
+            slow = slow.next;
+            fast = fast.next;
+        }
+
+        slow.next = slow.next.next;
+
+        return head;
+    }
+
+    private static class ListNode {
+        ListNode next;
+    }
+}

src/matrix/SpiralMatrix.java

@@ -0,0 +1,62 @@
+package matrix;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Description: https://leetcode.com/problems/spiral-matrix
+ * Difficulty: Medium
+ * Time complexity: O(n * m)
+ * Space complexity: O(n * m)
+ */
+public class SpiralMatrix {
+
+    private static final int RIGHT = 0;
+    private static final int BOTTOM = 1;
+    private static final int LEFT = 2;
+    private static final int TOP = 3;
+
+    public List<Integer> spiralOrder(int[][] matrix) {
+        List<Integer> result = new ArrayList<>();
+
+        int rowStart = 0;
+        int rowEnd = matrix[0].length - 1;
+        int colStart = 0;
+        int colEnd = matrix.length - 1;
+
+        int direction = RIGHT;
+
+        while (rowStart <= rowEnd && colStart <= colEnd) {
+            switch (direction) {
+                case RIGHT:
+                    for (int i = rowStart; i <= rowEnd; i++) {
+                        result.add(matrix[colStart][i]);
+                    }
+                    colStart++;
+                    break;
+                case BOTTOM:
+                    for (int i = colStart; i <= colEnd; i++) {
+                        result.add(matrix[i][rowEnd]);
+                    }
+                    rowEnd--;
+                    break;
+                case LEFT:
+                    for (int i = rowEnd; i >= rowStart; i--) {
+                        result.add(matrix[colEnd][i]);
+                    }
+                    colEnd--;
+                    break;
+                case TOP:
+                    for (int i = colEnd; i >= colStart; i--) {
+                        result.add(matrix[i][rowStart]);
+                    }
+                    rowStart++;
+                    break;
+            }
+
+            direction = (direction + 1) % 4;
+        }
+
+        return result;
+    }
+}

src/matrix/ValidSudoku.java

@@ -0,0 +1,32 @@
+package matrix;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Description: https://leetcode.com/problems/valid-sudoku
+ * Difficulty: Medium
+ * Time complexity: O(n * m)
+ * Space complexity: O(n * m)
+ */
+public class ValidSudoku {
+
+    public boolean isValidSudoku(char[][] board) {
+        Set<String> seen = new HashSet<>();
+
+        for (int i = 0; i < board.length; i++) {
+            for (int j = 0; j < board[0].length; j++) {
+                char cell = board[i][j];
+                if (cell == '.') continue;
+
+                if (!seen.add(cell + " in row " + i)
+                        || !seen.add(cell + " in col " + j)
+                        || !seen.add(cell + " in square " + i/3 + ":" + j/3)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}

src/recursion/CombinationSum.java

@@ -6,8 +6,8 @@
 /**
  * Description: https://leetcode.com/problems/combination-sum
  * Difficulty: Medium
- * Time complexity: O(n * n!)
- * Space complexity: O(n)
+ * Time complexity: O(2^n)
+ * Space complexity: O(2^n)
  */
 public class CombinationSum {
 

src/recursion/CombinationSum2.java

@@ -0,0 +1,45 @@
+package recursion;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Description: https://leetcode.com/problems/combination-sum-ii
+ * Difficulty: Medium
+ * Time complexity: O(2^n)
+ * Space complexity: O(2^n)
+ */
+public class CombinationSum2 {
+
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        Arrays.sort(candidates);
+
+        List<List<Integer>> combinations = new ArrayList<>();
+        backtrack(candidates, 0, new ArrayList<>(), target, combinations);
+
+        return combinations;
+    }
+
+    private void backtrack(
+            int[] candidates,
+            int start,
+            List<Integer> combination,
+            int remains,
+            List<List<Integer>> result) {
+        if (remains < 0) return;
+
+        if (remains == 0) {
+            result.add(new ArrayList<>(combination));
+            return;
+        }
+
+        for (int i = start; i < candidates.length; i++) {
+            if (i > start && candidates[i] == candidates[i - 1]) continue;
+
+            combination.add(candidates[i]);
+            backtrack(candidates, i + 1, combination, remains - candidates[i], result);
+            combination.remove(combination.size() - 1);
+        }
+    }
+}

src/recursion/GenerateParentheses.java

@@ -7,7 +7,7 @@
  * Description: https://leetcode.com/problems/generate-parentheses
  * Difficulty: Medium
  * Time complexity: O(2^2n)
- * Space complexity: O(n)
+ * Space complexity: O(2^2n)
  */
 public class GenerateParentheses {