[hyunjung-choi] WEEK 07 solutions

longest-substring-without-repeating-characters/hyunjung-choi.kt

@@ -0,0 +1,24 @@
+/**
+ * 시간복잡도: O(n)
+ * 공간복잡도: O(min(m,n)) - m은 문자셋 크기
+ */
+
+class Solution {
+    fun lengthOfLongestSubstring(s: String): Int {
+        val seen = mutableSetOf<Char>()
+        var left = 0
+        var maxLength = 0
+
+        for (right in s.indices) {
+            while (s[right] in seen) {
+                seen.remove(s[left])
+                left++
+            }
+
+            seen.add(s[right])
+            maxLength = maxOf(maxLength, right - left + 1)
+        }
+
+        return maxLength
+    }
+}

number-of-islands/hyunjung-choi.kt

@@ -0,0 +1,38 @@
+/**
+ * 시간복잡도: O(M × N)
+ * 공간복잡도: O(M × N)
+ */
+
+class Solution {
+    fun numIslands(grid: Array<CharArray>): Int {
+        if (grid.isEmpty() || grid[0].isEmpty()) return 0
+
+        val row = grid.size
+        val column = grid[0].size
+        var isIslandCount = 0
+
+        for (i in 0 until row) {
+            for (j in 0 until column) {
+                if (grid[i][j] == '1') {
+                    isIslandCount++
+                    dfs(grid, i, j, row, column)
+                }
+            }
+        }
+
+        return isIslandCount
+    }
+
+    private fun dfs(grid: Array<CharArray>, i: Int, j: Int, row: Int, column: Int) {
+        if (i < 0 || i >= row || j < 0 || j >= column || grid[i][j] != '1') {
+            return
+        }
+
+        grid[i][j] = '0'
+
+        dfs(grid, i - 1, j, row, column)
+        dfs(grid, i + 1, j, row, column)
+        dfs(grid, i, j - 1, row, column)
+        dfs(grid, i, j + 1, row, column)
+    }
+}

reverse-linked-list/hyunjung-choi.kt

@@ -0,0 +1,25 @@
+/**
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+
+class Solution {
+    fun reverseList(head: ListNode?): ListNode? {
+        var prev: ListNode? = null
+        var current = head
+
+        while (current != null) {
+            val next = current.next
+            current.next = prev
+            prev = current
+            current = next
+        }
+
+        return prev
+    }
+}

set-matrix-zeroes/hyunjung-choi.kt

@@ -0,0 +1,57 @@
+/**
+ * 시간복잡도: O(m × n)
+ * 공간복잡도: O(1)
+ */
+
+class Solution {
+    fun setZeroes(matrix: Array<IntArray>): Unit {
+        val m = matrix.size
+        val n = matrix[0].size
+
+        var firstRowHasZero = false
+        var firstColumnHasZero = false
+
+        for (j in 0 until n) {
+            if (matrix[0][j] == 0) {
+                firstRowHasZero = true
+                break
+            }
+        }
+
+        for (i in 0 until m) {
+            if (matrix[i][0] == 0) {
+                firstColumnHasZero = true
+                break
+            }
+        }
+
+        for (i in 1 until m) {
+            for (j in 1 until n) {
+                if (matrix[i][j] == 0) {
+                    matrix[i][0] = 0
+                    matrix[0][j] = 0
+                }
+            }
+        }
+
+        for (i in 1 until m) {
+            for (j in 1 until n) {
+                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
+                    matrix[i][j] = 0
+                }
+            }
+        }
+
+        for (j in 0 until n) {
+            if (firstRowHasZero) {
+                matrix[0][j] = 0
+            }
+        }
+
+        for (i in 0 until m) {
+            if (firstColumnHasZero) {
+                matrix[i][0] = 0
+            }
+        }
+    }
+}

unique-paths/hyunjung-choi.kt

@@ -0,0 +1,18 @@
+/**
+ * 시간 복잡도: O(m * n)
+ * 공간 복잡도: O(n)
+ */
+
+class Solution {
+    fun uniquePaths(m: Int, n: Int): Int {
+        val dp = IntArray(n) { 1 }
+
+        for (i in 1 until m) {
+            for (j in 1 until n) {
+                dp[j] += dp[j - 1]
+            }
+        }
+
+        return dp[n - 1]
+    }
+}