Merge pull request #2538 from sadie100/main

[sadie100] WEEK7 Solutions

Author: sadie100

design-add-and-search-words-data-structure/sadie100.ts

@@ -0,0 +1,72 @@
+/*
+words를 맵형태로 저장, 각 스펠링과 다음에 나오는 문자열을 key-value로 하는 맵으로 저장
+.의 경우 모든 경우를 탐색한다
+
+시간복잡도 :
+    addWord : O(L) (L은 words의 길이)
+    search : 일반적으로 O(L), .이 많으면 O(26^k) (k는 .의 개수)
+
+*/
+class TrieNode {
+  children: Map<string, TrieNode>
+  isEnd: boolean
+
+  constructor() {
+    this.children = new Map()
+    this.isEnd = false
+  }
+}
+
+class WordDictionary {
+  words = new TrieNode()
+  constructor() {}
+
+  addWord(word: string): void {
+    let curWords = this.words
+
+    for (let i = 0; i < word.length; i++) {
+      const char = word[i]
+
+      if (!curWords.children.has(char)) {
+        curWords.children.set(char, new TrieNode())
+      }
+
+      curWords = curWords.children.get(char)
+    }
+    curWords.isEnd = true
+  }
+
+  search(word: string): boolean {
+    return this.searchRecursively(word, this.words)
+  }
+
+  searchRecursively(word: string, area: TrieNode) {
+    for (let i = 0; i < word.length; i++) {
+      if (!area) return false
+      const char = word[i]
+
+      if (char === '.') {
+        const values = [...area.children.values()]
+
+        for (let newArea of values) {
+          const result = this.searchRecursively(word.slice(i + 1), newArea)
+          if (result) return true
+        }
+        return false
+      } else {
+        if (!area.children.has(char)) return false
+        area = area.children.get(char)
+      }
+    }
+
+    if (area.isEnd) return true
+    return false
+  }
+}
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * var obj = new WordDictionary()
+ * obj.addWord(word)
+ * var param_2 = obj.search(word)
+ */

longest-substring-without-repeating-characters/sadie100.ts

@@ -0,0 +1,30 @@
+/*
+투 포인터 start와 end 생성, end를 1씩 증가하며 s를 탐색한다
+각 문자열의 마지막 위치를 기록하는 locate Map을 생성한다
+end값이 locate에 이미 존재하는데 start가 해당값+1보다 작을 경우, start를 해당값+1로 변경하고 locate를 업데이트, 이어서 탐색한다
+매번 탐색마다 최대 길이 result를 갱신한다
+
+시간복잡도 : O(N) - 단일 순회
+공간복잡도 : O(N) (locate Map)
+
+
+*/
+
+function lengthOfLongestSubstring(s: string): number {
+  let start = 0
+  let end = 0
+  const locate = new Map()
+  let result = 0
+
+  while (end < s.length) {
+    let char = s[end]
+    if (locate.has(char)) {
+      start = Math.max(start, locate.get(char) + 1)
+    }
+    locate.set(char, end)
+    result = Math.max(result, end - start + 1)
+    end += 1
+  }
+
+  return result
+}

number-of-islands/sadie100.ts

@@ -0,0 +1,45 @@
+/*
+m x n visited 이중배열을 만들고 grid를 탐색,
+visited false면서 1값이 있는 타일이 있으면 dfs로 상하좌우를 탐색, visited true로 만든 뒤 result+=1한다
+탐색이 마치면 result를 리턴한다
+
+시간복잡도 : O(M + N)
+공간복잡도 : O(M + N) - visited
+*/
+
+const dx = [0, 1, -1, 0]
+const dy = [1, 0, 0, -1]
+
+function numIslands(grid: string[][]): number {
+  const visited = Array.from({ length: grid.length }, () =>
+    new Array(grid[0].length).fill(false),
+  )
+  let result = 0
+
+  function search(row: number, col: number) {
+    visited[row][col] = true
+
+    for (let i = 0; i < 4; i++) {
+      const newRow = row + dx[i]
+      const newCol = col + dy[i]
+
+      if (newRow < 0 || newRow >= grid.length) continue
+      if (newCol < 0 || newCol >= grid[0].length) continue
+
+      if (visited[newRow][newCol] === false && grid[newRow][newCol] === '1') {
+        search(newRow, newCol)
+      }
+    }
+  }
+
+  for (let i = 0; i < grid.length; i++) {
+    for (let j = 0; j < grid[0].length; j++) {
+      if (visited[i][j] === false && grid[i][j] === '1') {
+        search(i, j)
+        result += 1
+      }
+    }
+  }
+
+  return result
+}

reverse-linked-list/sadie100.ts

@@ -0,0 +1,34 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+/*
+직전 노드를 담는 변수 before과 다음 노드를 담는 변수 next, 순회중인 노드 head 변수와 함께 list를 순회
+head의 next에 before을 넣고, head를 next로 변환하며 head가 null이 아닐 때까지 반복한다
+
+시간복잡도 : O(N) - 1번 순회
+공간복잡도 : O(1) - before, next 변수
+
+*/
+function reverseList(head: ListNode | null): ListNode | null {
+  if (!head) return head
+  let originNext = head.next
+  let before = null
+
+  while (head !== null) {
+    originNext = head.next
+    head.next = before
+    before = head
+    head = originNext
+  }
+
+  return before
+}

unique-paths/sadie100.ts

@@ -0,0 +1,20 @@
+/*
+dp 배열 생성, top-left에서 bottom-right로 이동하며 위 값, 왼쪽 값을 더하며 dp를 업데이트, 마지막 원소를 리턴한다
+
+시간복잡도 : O(m * n)
+*/
+
+const dx = [0, 1]
+const dy = [1, 0]
+
+function uniquePaths(m: number, n: number): number {
+  const dp = Array.from({ length: m }, () => new Array(n).fill(1))
+
+  for (let i = 1; i < m; i++) {
+    for (let j = 1; j < n; j++) {
+      dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+    }
+  }
+
+  return dp[m - 1][n - 1]
+}