#272 #282 solution

Author: sungjinwi

container-with-most-water/sungjinwi.cpp

@@ -1,20 +1,32 @@
+/*
+    풀이 :
+        최대 넓이는 양 끝 기둥 길이 중 짧은 쪽을 기준으로 정해진다
+        양 끝에서 기둥을 시작하고 둘 중 짧은 쪽을 안쪽으로 이동하면서 최대 넓이를 찾는다
+
+    height의 개수 : N
+
+    TC : O(N)
+
+    SC : O(1)
+*/
+
 class Solution {
     public:
         int maxArea(vector<int>& height) {
             int left = 0;
             int right = height.size() - 1;
-            int ans = 0;
+            int max_area = 0;
 
             while (left < right)
             {
-                int cur = (right - left) * min(height[left], height[right]);
-                if (cur > ans)
-                    ans = cur;
+                int cur_area = (right - left) * min(height[left], height[right]);
+                if (cur_area > max_area)
+                    max_area = cur_area;
                 if (height[left] <= height[right])
                     left++;
                 else
                     right--;
             }
-            return ans;
+            return max_area;
         }
     };

longest-increasing-subsequence/sungjinwi.cpp

@@ -0,0 +1,33 @@
+/*
+    nums와 길이가 같은 dp배열을 만들고 1로 초기화한다
+    dp[i]의 값은 nums[i]으로 끝나는 LIS의 길이
+    i 이후의 j에 대해 nums[j] > nums[i]일 경우 nums[j]를 nums[i]로 끝나는 LIS에 붙일 수 있으므로
+    dp[j]와 dp[i + 1]을 비교해 큰 값으로 업데이트
+
+    nums의 길이 : N
+
+    TC : O(N^2)
+        반복문 내부의 반복문
+
+    SC : O(N)
+        dp의 길이는 nums길이에 비례
+*/
+
+class Solution {
+    public:
+        int lengthOfLIS(vector<int>& nums) {
+            vector<int> dp(nums.size(), 1);
+            int max_len = 1;
+    
+            for (int i = 0; i < nums.size(); i++)
+                for (int j = i + 1; j < nums.size(); j++)
+                {
+                    if (nums[j] > nums[i])
+                    {
+                        dp[j] = max(dp[i] + 1, dp[j]);
+                        max_len = max(dp[j], max_len);
+                    }
+                }
+            return max_len;
+        }
+    };

spiral-matrix/sungjinwi.cpp

@@ -0,0 +1,46 @@
+/*
+    풀이 :
+        상하좌우 범위지정해서 이동하는 것이 아니라 n_rows, n_cols 길이만큼 이동으로 풀이
+        col 방향으로 움직이면 이동할 row 감소, row 방향 움직이면 n_cols 1 감소
+        row, col 한번씩 이동하면 direction *= -1로 방향을 바꿔준다
+
+    matrix 크기 : M * N
+
+    TC : O(M * N)
+        matrix 전체 순환
+
+    SC : O(1)
+        리턴할 ans 제외하면 추가 메모리 사용은 상수 개수의 변수
+*/
+
+class Solution {
+    public:
+        vector<int> spiralOrder(vector<vector<int>>& matrix) {
+            int n_rows = matrix.size();
+            int n_cols = matrix[0].size();
+            vector<int> ans;
+    
+            int row = 0, col = -1;
+            int direction = 1;
+    
+            while (n_rows > 0 && n_cols > 0)
+            {
+                for (int i = 0; i < n_cols; i++)
+                {
+                    col += direction;
+                    ans.push_back(matrix[row][col]);
+                }
+                n_rows--;
+    
+                for (int i = 0; i < n_rows; i++)
+                {
+                    row += direction;
+                    ans.push_back(matrix[row][col]);
+                }
+                n_cols--;
+    
+                direction *= -1;
+            }
+            return ans;
+        }
+    };

valid-parentheses/sungjinwi.cpp

@@ -1,5 +1,16 @@
 /*
-    
+    풀이 : 
+        stack을 이용해서 괄호를 넣고 뺸다.
+        닫는 괄호 ),],}를 만났을 때 가장 위의 괄호가 대응하는 괄호면 제거하고 비어있거나 맞지 않는 괄호면 return false
+        string을 모두 순회했을 떄 stack이 비어있지 않으면 return false
+
+    s의 길이 N
+
+    TC : O(N)
+        s에 대해 반복 1회
+
+    SC : O(N)
+        최악의 경우 stack 크기는 s의 길이에 비례
 */
 
 class Solution {