Merge pull request #486 from obzva/main

[Flynn] Week7

longest-substring-without-repeating-characters/flynn.cpp

@@ -0,0 +1,42 @@
+/**
+ * 풀이
+ * - 주어진 문자열 `s`를 한 번 조회합니다
+ * - lookup이라는 해시맵 객체를 이용하여 현재 조회하고 있는
+ *   substring에 반복되는 문자가 있는지 검사합니다
+ * 
+ * Big O
+ * - N: 주어진 문자열 `s`의 길이
+ * 
+ * - Time complexity: O(N)
+ * - Space complexity: O(N)
+ */
+
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        if (s.size() == 0) return 0;
+
+        unordered_map<char, int> lookup;
+        lookup.insert({s[0], 0});
+
+        int res = 1;
+
+        int start = 0;
+        int end = 1;
+
+        while (end < s.size()) {
+            if (lookup.find(s[end]) != lookup.end()
+                && lookup[s[end]] >= start) {
+                start = lookup[s[end]] + 1;
+            }
+
+            lookup[s[end]] = end;
+
+            res = max(res, end - start + 1);
+
+            ++end;
+        }
+
+        return res;
+    }
+};

number-of-islands/flynn.cpp

@@ -0,0 +1,59 @@
+/**
+ * 풀이
+ * - bfs를 활용합니다
+ * 
+ * Big O
+ * - M: grid의 행의 수
+ * - N: grid의 열의 수
+ * 
+ * - Time complexity: O(MN)
+ *   - 각 좌표는 최대 한 번씩만 조회하게 됩니다
+ * - Space complexity: O(MN)
+ *   - 방문 여부를 기록하기 위해 visit 배열이 사용됩니다
+ *   - queue에 쌓이는 원소의 개수는 최대 MN개까지 증가할 수 있습니다
+ */
+
+class Solution {
+public:
+    int numIslands(vector<vector<char>>& grid) {
+        int m = grid.size();
+        int n = grid[0].size();
+
+        vector<vector<bool>> visit;
+        for (int r = 0; r < m; ++r) {
+            vector<bool> row;
+            for (int c = 0; c < n; ++c) {
+                row.push_back(false);
+            }
+            visit.push_back(row);
+        }
+
+        pair<int, int> dirs[4] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+
+        int res = 0;
+        queue<pair<int, int>> q;
+        for (int r = 0; r < m; ++r) {
+            for (int c = 0; c < n; ++c) {
+                if (visit[r][c] == false && grid[r][c] == '1') {
+                    ++res;
+                    q.push({r, c});
+                    while (!q.empty()) {
+                        auto p = q.front();
+                        q.pop();
+                        for (auto dir : dirs) {
+                            pair<int, int> next = {p.first + dir.first, p.second + dir.second};
+                            if (0 <= next.first && next.first < m && 0 <= next.second && next.second < n) {
+                                if (visit[next.first][next.second] == false && grid[next.first][next.second] == '1') {
+                                    q.push(next);
+                                    visit[next.first][next.second] = true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return res;
+    }
+};

reverse-linked-list/flynn.cpp

@@ -0,0 +1,54 @@
+/**
+ * 풀이
+ * - 생략, 주석 참고
+ * 
+ * Big O
+ * - N: 주어진 링크드 리스트 `head`의 길이
+ * 
+ * - Time complexity: O(N)
+ * - Space complexity: O(1)
+ */
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* reverseList(ListNode* head) {
+        if (head == nullptr) return head;
+        // example: a - b - c - d
+
+        ListNode* root = new ListNode();
+        root->next = head;
+        // root - a - b - c - d
+
+        ListNode* p = head;
+        ListNode* q = p->next;
+        // root - a - b - c - d
+        //       (p) (q)
+
+        while (q != nullptr) {
+            p->next = q->next;
+            // root - a - c - d
+            //        b /
+            q->next = root->next;
+            // root - a - c - d
+            //    b /
+            root->next = q;
+            // root - b - a - c - d
+            //       (q) (p)
+            q = p->next;
+            // root - b - a - c - d
+            //           (p) (q)
+        }
+
+        return root->next;
+    }
+};

set-matrix-zeroes/flynn.cpp

@@ -0,0 +1,60 @@
+/**
+ * 풀이
+ * - matrix 전체를 탐색하다가 값이 0인 좌표를 찾으면
+ *   그 좌표의 첫번째 열, 첫번째 행 좌표에 표시를 합니다
+ *   if matrix[r][c] == 0
+ *     matrix[r][0] = 0
+ *     matrix[0][c] = 0
+ * - 만약 해당 좌표가 첫번째 행이거나 첫번째 열이라면 따로 기록해둡니다
+ * - 첫번째 완전탐색을 마친 후엔 matrix의 첫번째 행, 열을 보고 문제에서 요구하는 바를 수행합니다
+ * 
+ * Big O
+ * - M: matrix의 행 개수
+ * - N: matrix의 열 개수
+ * 
+ * - Time complexity: O(MN)
+ * - Space complexity: O(1)
+ *     
+ */
+
+class Solution {
+public:
+    void setZeroes(vector<vector<int>>& matrix) {
+        int m = matrix.size();
+        int n = matrix[0].size();
+
+        bool first_row = false;
+        bool first_col = false;
+
+        for (int r = 0; r < m; ++r) {
+            for (int c = 0; c < n; ++c) {
+                if (!matrix[r][c]) {
+                    if (!r) first_row = true;
+                    if (!c) first_col = true;
+                    matrix[r][0] = 0;
+                    matrix[0][c] = 0;
+                }
+            }
+        }
+
+        for (int r = 1; r < m; ++r) {
+            if (!matrix[r][0]) {
+                for (int c = 1; c < n; ++c) matrix[r][c] = 0;
+            }
+        }
+
+        for (int c = 1; c < n; ++c) {
+            if (!matrix[0][c]) {
+                for (int r = 1; r < m; ++r) matrix[r][c] = 0;
+            }
+        }
+
+        if (first_row) {
+            for (int c = 0; c < n; ++c) matrix[0][c] = 0;
+        }
+
+        if (first_col) {
+            for (int r = 0; r < m; ++r) matrix[r][0] = 0;
+        }
+    }
+};

unique-paths/flynn.cpp

@@ -0,0 +1,31 @@
+/**
+ * 풀이
+ * - 조합 공식을 사용하면 overflow 및 시간초과를 일으킬 수 있습니다
+ * - 모든 좌표에 대해 uniquePaths를 계산하는 방식을 사용합니다
+ * - 특정 좌표의 uniquePaths를 계산하기 위해서는 두 행만 필요하기 때문에 길이 m의 배열 두 개를 이용합니다
+ * 
+ * Big O
+ * - Time complexity: O(MN)
+ * - Space compexity: O(N)
+ */
+
+class Solution {
+public:
+    int uniquePaths(int m, int n) {
+        vector<int> row1;
+        vector<int> row2;
+
+        for (int i = 0; i < n; ++i) row1.push_back(1);
+        row2.push_back(1);
+        for (int i = 1; i < n; ++i) row2.push_back(0);
+
+        for (int j = 1; j < m; ++j) {
+            for (int i = 1; i < n; ++i) row2[i] = row1[i] + row2[i - 1];
+            swap(row1, row2);
+            row2[0] = 1;
+            for (int i = 1; i < n; ++i) row2[i] = 0;
+        }
+
+        return row1[n - 1];
+    }
+};