Merge pull request #885 from gmlwls96/main

[gmlwls96] Week 6

Author: gmlwls96

container-with-most-water/gmlwls96.kt

@@ -0,0 +1,22 @@
+class Solution {
+    /** 시간 : O(n), 공간 : O(1)*/
+    fun maxArea(height: IntArray): Int {
+        var maxDiff = 0
+        var left = 0
+        var right = height.lastIndex
+        // left, right값을 순차적으로 조회해서 물높이를 구하고,
+        // left < right값 보다 작으면 left증가시킨다. 반대는 right 감소
+        while (left < right) {
+            maxDiff = max(maxDiff, (right - left) * min(height[left], height[right]))
+            // 너비 : right - left
+            // 현재 높이 :  min(height[left], height[right])
+            // 너비 * 현재 높이가 maxDiff 비교하여 더 큰값이 maxDiff가 된다.
+            if (height[left] < height[right]) {
+                left++
+            } else {
+                right--
+            }
+        }
+        return maxDiff
+    }
+}

design-add-and-search-words-data-structure/gmlwls96.kt

@@ -0,0 +1,48 @@
+class Node() {
+    val map = mutableMapOf<Char, Node?>()
+    var isEnd = false
+}
+
+class WordDictionary() {
+
+    val rootNode = Node()
+
+    // 시간 : O(n), 공간 : O(n)
+    fun addWord(word: String) {
+        var currentNode = rootNode
+        for (i in word.indices) {
+            val char = word[i]
+            if (currentNode.map[char] == null) {
+                currentNode.map[char] = Node()
+            }
+            currentNode = currentNode.map[char]!!
+        }
+        currentNode.isEnd = true
+    }
+
+    // 시간 : O(26*n), 공간: O(n)
+    fun search(word: String): Boolean {
+        return dfs(
+            pos = 0,
+            word = word,
+            node = rootNode
+        )
+    }
+
+    fun dfs(pos: Int, word: String, node: Node): Boolean {
+        var result = false
+        val char = word[pos]
+        val isLast = word.lastIndex == pos
+        node.map.forEach {
+            if (char == '.' || char == it.key) {
+                if (isLast) {
+                    result = true
+                    return@forEach
+                } else {
+                    result = result or dfs(pos + 1, word, it.value!!)
+                }
+            }
+        }
+        return result
+    }
+}

longest-increasing-subsequence/gmlwls96.kt

@@ -0,0 +1,20 @@
+class Solution {
+    // 시간 : O(n), 공간 : O(n)
+    // nums를 조회하면서 이전값과 비교하여
+    // 더 증가하였으면  : 이전 카운트 +1
+    // 같거나 작으면 : 이전 카운트값
+    fun lengthOfLIS(nums: IntArray): Int {
+        val count = IntArray(nums.size)
+        count[0] = 1
+        var prev = nums[0]
+        for (i in 1 until nums.size) {
+            if (prev < nums[i]) {
+                count[i] += count[i - 1] + 1
+            } else {
+                count[i] = count[i - 1]
+            }
+            prev = nums[i]
+        }
+        return count.last()
+    }
+}

spiral-matrix/gmlwls96.kt

@@ -0,0 +1,29 @@
+class Solution {
+    // 시간 : O(y*x), 공간 : O(1)
+    fun spiralOrder(matrix: Array<IntArray>): List<Int> {
+        val result = mutableListOf<Int>()
+        if (matrix.isEmpty() || matrix[0].isEmpty()) return result
+
+        var top = 0
+        var bottom = matrix.size - 1
+        var left = 0
+        var right = matrix[0].size - 1
+
+        while (top <= bottom && left <= right) {
+            for (i in left..right) result.add(matrix[top][i])
+            top++
+            for (i in top..bottom) result.add(matrix[i][right])
+            right--
+            if (top <= bottom) {
+                for (i in right downTo left) result.add(matrix[bottom][i])
+                bottom--
+            }
+            if (left <= right) {
+                for (i in bottom downTo top) result.add(matrix[i][left])
+                left++
+            }
+        }
+
+        return result
+    }
+}

valid-parentheses/gmlwls96.kt

@@ -0,0 +1,27 @@
+package leetcode_study
+
+class Solution {
+    /** 시간 : O(n), 공간 : O(n) */
+    fun isValid(s: String): Boolean {
+        val stack = Stack<Char>()
+        val openParentheses = "([{"
+        s.forEach {
+            if (openParentheses.contains(it)) {
+                stack.push(it)
+            } else {
+                if (stack.isEmpty()) {
+                    return false
+                }
+                val top = stack.pop()
+                if (
+                    top == openParentheses[0] && it != ')' ||
+                    top == openParentheses[1] && it != ']' ||
+                    top == openParentheses[2] && it != '}'
+                ) {
+                    return false
+                }
+            }
+        }
+        return stack.isEmpty()
+    }
+}