Merge pull request #2528 from hwi-middle/main

[hwi-middle] WEEK 06 solutions

Author: hwi-middle

container-with-most-water/hwi-middle.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int l = 0;
+        int r = height.size() - 1;
+
+        int area = 0;
+
+        // 투 포인터로 접근
+        while (l < r)
+        {
+            // 너비(물 저장량)를 구하고 최댓값 업데이트
+            area = max(area, (r - l) * min(height[r], height[l]));
+
+            // 높이가 낮은 쪽의 커서를 이동
+            // -> 높은 쪽의 커서를 움직이면 무조건 손해
+            // -> 너비는 줄어들고 높이까지 줄어드니까
+            if (height[l] < height[r])
+            {
+                l++;
+            }
+            else
+            {
+                r--;
+            }
+        }
+
+        return area;
+    }
+};

design-add-and-search-words-data-structure/hwi-middle.cpp

@@ -0,0 +1,71 @@
+// 풀이 접근: Trie로 해결
+
+class WordDictionary {
+public:
+    WordDictionary() {
+        mRoot = make_unique<Node>(); // RAII를 위해 스마트 포인터 사용
+    }
+    
+    void addWord(string word) {
+        Node* curNode = mRoot.get();
+		for (char c : word)
+		{
+            auto& child = curNode->children[c - 'a'];
+    		if (child == nullptr)
+			{
+				child = make_unique<Node>();
+			}
+
+			curNode = child.get();
+		}
+
+		curNode->isWord = true;
+    }
+    
+    bool search(string word) {
+        return search_impl(word, mRoot.get());
+    }
+
+private:
+	struct Node
+	{
+		bool isWord = false;
+		unique_ptr<Node> children[26];
+	};
+
+	unique_ptr<Node> mRoot;
+
+    // 복사 없는 substr을 위해 std::string_view 활용
+    bool search_impl(string_view word, Node* root)
+    {
+        Node* curNode = root;
+		for (int i = 0; i < word.size(); ++i)
+		{
+            char c = word[i];
+            if (c == '.') // '.'은 와일드 카드이므로 자식 노드를 모두 순회하며 시도
+            {
+                for (auto& p : curNode->children)
+                {
+                    if (p != nullptr && search_impl(word.substr(i + 1), p.get()))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+            else
+            {
+                auto& child = curNode->children[c - 'a'];
+                if (child == nullptr)
+                {
+                    return false;
+                }
+
+                curNode = child.get();
+            }
+		}
+
+		return curNode->isWord;
+    }
+};

longest-increasing-subsequence/hwi-middle.cpp

@@ -0,0 +1,48 @@
+// O(n^2) 풀이
+class Solution {
+public:
+    int lengthOfLIS(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> d(n); // 점화식: d[i] = a[i]를 마지막으로 하는 LIS 길이
+
+        for (int i = 0; i < n; ++i)
+        {
+            d[i] = 1; // 최솟값은 1
+            for (int j = 0; j < i; ++j)
+            {
+                // 증가하는 부분수열이고, 기존에 구한 길이보다 길면 업데이트
+                if (nums[j] < nums[i] && d[j] + 1 > d[i])
+                {
+                    d[i] = d[j] + 1;
+                }
+            }
+        }
+
+        // d의 최댓값 반환
+        return *max_element(d.begin(), d.end());
+    }
+};
+
+// O(n log n) 풀이
+class Solution {
+public:
+    int lengthOfLIS(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> d; // d[i] = 길이가 i + 1인 LIS의 가장 작은 마지막 값
+
+        for (int i = 0; i < n; ++i)
+        {
+            auto it = lower_bound(d.begin(), d.end(), nums[i]);
+            if (it == d.end()) // nums[i]가 d의 모든 원소보다 큰 경우
+            {
+                d.push_back(nums[i]);
+            }
+            else // nums[i]의 자리를 찾은 경우
+            {
+                *it = nums[i]; // 그냥 대체하는게 이득임 -> 길이는 유지됐고, 더 이어붙일 수 있는 수의 범위는 늘어나므로
+            }
+        }
+
+        return d.size();
+    }
+};

spiral-matrix/hwi-middle.cpp

@@ -0,0 +1,54 @@
+class Solution {
+public:
+    vector<int> spiralOrder(vector<vector<int>>& matrix) {
+        int m = matrix.size();
+        int n = matrix[0].size();
+
+        int top = 0;
+        int bottom = m - 1;
+        int left = 0;
+        int right = n - 1;
+
+        vector<int> v;
+        v.reserve(m * n);
+
+        while(top <= bottom && left <= right)
+        {
+            // 오른쪽으로 이동
+            for (int i = left; i <= right; ++i)
+            {
+                v.push_back(matrix[top][i]);
+            }
+            top++;
+
+            // 아래쪽으로 이동
+            for (int i = top; i <= bottom; ++i)
+            {
+                v.push_back(matrix[i][right]);
+            }
+            right--;
+
+            // 왼쪽으로 이동
+            if (top <= bottom)
+            {
+                for (int i = right; i >= left; --i)
+                {
+                    v.push_back(matrix[bottom][i]);
+                }
+                bottom--;
+            }
+
+            // 위쪽으로 이동
+            if (left <= right)
+            {
+                for (int i = bottom; i >= top; --i)
+                {
+                    v.push_back(matrix[i][left]);
+                }
+                left++;
+            }
+        }
+
+        return v;
+    }
+};

valid-parentheses/hwi-middle.cpp

@@ -0,0 +1,50 @@
+class Solution {
+public:
+    bool isValid(string s) {
+        stack<char> st; // 여는 괄호를 저장할 스택
+
+        for (char ch : s)
+        {
+            if (isOpening(ch)) // 여는 괄호라면 스택에 push
+            {
+                st.push(ch);
+                continue;
+            }
+
+            if (st.empty()) // 스택이 비었는데 닫는 괄호면 invalid
+            {
+                return false;
+            }
+
+            char t = st.top();
+            st.pop();
+
+            // 괄호 쌍이 맞으면 계속 진행
+            if ((ch == ')' && t == '(')
+            || (ch == ']' && t == '[')
+            || (ch == '}' && t == '{'))
+            {
+                continue;
+            }
+
+            // 괄호 쌍이 맞지 않으면 invalid
+            return false;
+        }
+
+        return st.empty();
+    }
+
+private:
+    bool isOpening(char c)
+    {
+        switch(c)
+        {
+            case '(':
+            case '[':
+            case '{':
+                return true;
+        }
+
+        return false;
+    }
+};