From 2f45ccfc3b3dce2e6ce9701fe9e4a2a3f5f26301 Mon Sep 17 00:00:00 2001 From: jonghoonpark Date: Wed, 5 Jun 2024 09:52:28 +0900 Subject: [PATCH] week6 mission done --- container-with-most-water/dev-jonghoonpark.md | 38 +++++++++++++++++++ .../dev-jonghoonpark.md | 21 ++++++++++ .../dev-jonghoonpark.md | 36 ++++++++++++++++++ .../dev-jonghoonpark.md | 34 +++++++++++++++++ .../dev-jonghoonpark.md | 33 ++++++++++++++++ 5 files changed, 162 insertions(+) create mode 100644 container-with-most-water/dev-jonghoonpark.md create mode 100644 find-minimum-in-rotated-sorted-array/dev-jonghoonpark.md create mode 100644 longest-repeating-character-replacement/dev-jonghoonpark.md create mode 100644 longest-substring-without-repeating-characters/dev-jonghoonpark.md create mode 100644 search-in-rotated-sorted-array/dev-jonghoonpark.md diff --git a/container-with-most-water/dev-jonghoonpark.md b/container-with-most-water/dev-jonghoonpark.md new file mode 100644 index 000000000..b72e49a96 --- /dev/null +++ b/container-with-most-water/dev-jonghoonpark.md @@ -0,0 +1,38 @@ +- 문제: https://leetcode.com/problems/container-with-most-water/ +- time complexity : O(n) +- space complexity : O(1) +- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/06/02/leetcode-11 + +```java +class Solution { + public int maxArea(int[] height) { + int start = 0; + int end = height.length - 1; + + int max = getArea(height, start, end); + + while(start < end) { + if(height[start] >= height[end]) { + end--; + max = Math.max(max, getArea(height, start, end)); + } else { + start++; + max = Math.max(max, getArea(height, start, end)); + } + } + + return max; + } + + public int getArea(int[] height, int start, int end) { + if (start == end) { + return 0; + } + return getMinHeight(height[end], height[start]) * (end - start); + } + + public int getMinHeight(int height1, int height2) { + return Math.min(height1, height2); + } +} +``` diff --git a/find-minimum-in-rotated-sorted-array/dev-jonghoonpark.md b/find-minimum-in-rotated-sorted-array/dev-jonghoonpark.md new file mode 100644 index 000000000..854e24dd6 --- /dev/null +++ b/find-minimum-in-rotated-sorted-array/dev-jonghoonpark.md @@ -0,0 +1,21 @@ +- 문제: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/ +- time complexity : O(log n) +- space complexity : O(1) +- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/06/03/leetcode-153 + +```java +public int findMin(int[] nums) { + int left = 0, right = nums.length - 1; + while(left < right) { + int mid = left + (right - left) / 2; + + if(nums[mid] < nums[right]) { + right = mid; + } else { + left = mid + 1; + } + } + + return nums[left]; +} +``` diff --git a/longest-repeating-character-replacement/dev-jonghoonpark.md b/longest-repeating-character-replacement/dev-jonghoonpark.md new file mode 100644 index 000000000..f46621cc9 --- /dev/null +++ b/longest-repeating-character-replacement/dev-jonghoonpark.md @@ -0,0 +1,36 @@ +- 문제: https://leetcode.com/problems/longest-repeating-character-replacement/ +- time complexity : O(n) +- space complexity : O(1) +- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/04/29/leetcode-424 + +```java +class Solution { + public int characterReplacement(String s, int k) { + int[] counter = new int[26]; + int countOfMostFrequent = -1; + + int headPointer = 0; + int tailPointer = 0; + + int maxLength = 0; + + while (headPointer < s.length()) { + char head = s.charAt(headPointer); + char tail = s.charAt(tailPointer); + counter[head - 'A']++; + headPointer++; + + countOfMostFrequent = Math.max(counter[head - 'A'], countOfMostFrequent); + while (headPointer - tailPointer > countOfMostFrequent + k) { + counter[tail - 'A']--; + tailPointer++; + tail = s.charAt(tailPointer); + } + + maxLength = Math.max(maxLength, headPointer - tailPointer); + } + + return maxLength; + } +} +``` diff --git a/longest-substring-without-repeating-characters/dev-jonghoonpark.md b/longest-substring-without-repeating-characters/dev-jonghoonpark.md new file mode 100644 index 000000000..0f50726c7 --- /dev/null +++ b/longest-substring-without-repeating-characters/dev-jonghoonpark.md @@ -0,0 +1,34 @@ +- 문제: https://leetcode.com/problems/longest-substring-without-repeating-characters/ +- time complexity : O(n) +- space complexity : O(n) +- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/02/18/leetcode-3 + +```java +class Solution { + public int lengthOfLongestSubstring(String s) { + if (s.isEmpty()) { + return 0; + } + + Set set = new HashSet<>(); + int pointer = 0; + int longest = 0; + + while (pointer < s.length()) { + char _char = s.charAt(pointer); + while (set.contains(_char)) { + set.remove(s.charAt(pointer - set.size())); + } + set.add(_char); + longest = Math.max(longest, set.size()); + pointer++; + } + + return longest; + } +} +``` + +## TC 추가 설명 + +내부 while이 있지만 O(n)으로 적을 수 있는 이유는 hashset의 경우 search 하는데 드는 비용이 O(1) 이기 때문이다. diff --git a/search-in-rotated-sorted-array/dev-jonghoonpark.md b/search-in-rotated-sorted-array/dev-jonghoonpark.md new file mode 100644 index 000000000..f22c01955 --- /dev/null +++ b/search-in-rotated-sorted-array/dev-jonghoonpark.md @@ -0,0 +1,33 @@ +- 문제: https://leetcode.com/problems/search-in-rotated-sorted-array/ +- time complexity : O(log n) +- space complexity : O(1) +- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/06/03/leetcode-33 + +```java +public int search(int[] nums, int target) { + int left = 0, right = nums.length - 1; + while(left <= right) { + int mid = left + (right - left) / 2; + + if (nums[mid] == target) { + return mid; + } + + if(nums[mid] < nums[right]) { + if (target < nums[mid] || target > nums[right]) { + right = mid - 1; + } else { + left = mid + 1; + } + } else { + if (target < nums[left] || target > nums[mid]) { + left = mid + 1; + } else { + right = mid - 1; + } + } + } + + return -1; +} +```