[이유진] Week 7

longest-substring-without-repeating-characters/Real-Reason.kt

@@ -0,0 +1,33 @@
+package leetcode_study
+
+/**
+ * 시간복잡도 : O(n) ?
+ * -
+ * 공간복잡도 : O(n)
+ * - charAndIdx 에 최대 n개의 문자에 대해서 담을 수 있으므로 O(n) 의 공간복잡도를 가집니다.
+ * */
+
+fun lengthOfLongestSubstring(s: String): Int {
+    var point = 0
+    val charAndIdx = HashMap<Char, Int>()
+    var cnt = 0
+    var maxCnt = 0
+
+    while (point < s.length) {
+        val nowChar = s[point]
+        if (nowChar !in charAndIdx.keys) {
+            charAndIdx[nowChar] = point
+            cnt += 1
+            point += 1
+        } else {
+            val prevSameCharIdx = charAndIdx[nowChar]!!
+            point = prevSameCharIdx + 1
+            charAndIdx.clear()
+            cnt = 0
+        }
+
+        maxCnt = maxOf(cnt, maxCnt)
+    }
+
+    return maxCnt
+}

number-of-islands/Real-Reason.kt

@@ -0,0 +1,57 @@
+package leetcode_study
+
+/**
+ * n: rowSize, m: colSize
+ * 시간복잡도 : O(n*m)
+ * - 전체 그리드를 한번씩만 방문하므로, 시간복잡도는 O(n*m) 과 같습니다.
+ * 공간복잡도 : O(n*m)
+ * - 방문이력에 대해 visited 를 저장하므로, 시간복잡도는 O(n*m) 과 같습니다.
+ * */
+class NumberOfIsland {
+    val directions = listOf(
+        Pair(-1, 0),
+        Pair(1, 0),
+        Pair(0, -1),
+        Pair(0, 1)
+    )
+    var rowSize = 0
+    var colSize = 0
+    var visited: Array<BooleanArray>? = null
+
+    fun numIslands(grid: Array<CharArray>): Int {
+        rowSize = grid.size
+        colSize = grid[0].size
+        visited = Array(rowSize) { BooleanArray(colSize) }
+
+        var islandCnt = 0
+
+        for (i in 0 until rowSize) {
+            for (j in 0 until colSize) {
+                if (grid[i][j] == '1' && !visited!![i][j]) {
+                    dfs(i, j, grid)
+                    islandCnt += 1
+                }
+            }
+        }
+
+        return islandCnt
+    }
+
+    fun dfs(r: Int, c: Int, grid: Array<CharArray>) {
+        visited!![r][c] = true
+
+        for ((dr, dc) in directions) {
+            val (nr, nc) = Pair(r + dr, c + dc)
+            if (isValid(nr, nc, grid)) {
+                dfs(nr, nc, grid)
+            }
+        }
+    }
+
+    private fun isValid(r: Int, c: Int, grid: Array<CharArray>): Boolean {
+        return r in 0 until rowSize &&
+                c in 0 until colSize &&
+                grid[r][c] == '1' &&
+                !visited!![r][c]
+    }
+}

reverse-linked-list/Real-Reason.kt

@@ -0,0 +1,63 @@
+package leetcode_study
+
+/**
+ * 첫번째 문제풀이
+ * 시간복잡도 : O(n)
+ * - n 번을 순회하며 nodes 에 저장하고, 다시 nodes 에서 노드를 하나씩 꺼내어 연산하므로 O(2n) -> O(n) 입니다.
+ * 공간복잡도 : O(n)
+ * - n 개의 노드를 nodes 에 저장하므로 O(n) 입니다.
+ *
+ * 두번째 문제풀이
+ * 시간복잡도 : O(n)
+ * - curr 이 null 일때까지 while 문을 돌고 있으므로, n번의 순회가 발생할 것입니다. 따라서 시간복잡도는 O(n) 입니다.
+ * 공간복잡도 : O(1)
+ * - nodes 를 저장했던 첫번째 풀이와 달리 prev, curr 두개의 상수만을 사용하므로 O(1) 만큼의 공간복잡도를 가집니다.
+ * */
+class ReverseLinkedList {
+    class ListNode(var `val`: Int) {
+        var next: ListNode? = null
+    }
+
+    fun reverseList(head: ListNode?): ListNode? {
+        var nowNode = head
+        val nodes = mutableListOf<ListNode>()
+
+        while (nowNode != null) {
+            nodes.add(nowNode)
+            nowNode = nowNode.next
+        }
+
+        val dummy = ListNode(-1)
+        nowNode = dummy
+
+        while (nodes.isNotEmpty()) {
+            val popNode = nodes.removeLast()
+            nowNode?.next = popNode
+            nowNode = nowNode?.next
+        }
+
+        nowNode?.next = null
+
+        return dummy.next
+    }
+}
+
+class ReverseLinkedList2 {
+    class ListNode(var `val`: Int) {
+        var next: ListNode? = null
+    }
+
+    fun reverseList(head: ListNode?): ListNode? {
+        var prev: ListNode? = null
+        var curr = head
+
+        while (curr != null) {
+            val temp = curr.next
+            curr.next = prev
+            prev = curr
+            curr = temp
+        }
+
+        return prev
+    }
+}