From e494ff9bc37cad7b19fd3d8ef492583d73ef4e6d Mon Sep 17 00:00:00 2001 From: jonghoonpark Date: Tue, 23 Jul 2024 04:52:00 +0900 Subject: [PATCH 1/5] week13 mission non-overlapping-intervals --- non-overlapping-intervals/dev-jonghoonpark.md | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 non-overlapping-intervals/dev-jonghoonpark.md diff --git a/non-overlapping-intervals/dev-jonghoonpark.md b/non-overlapping-intervals/dev-jonghoonpark.md new file mode 100644 index 000000000..5113e4b72 --- /dev/null +++ b/non-overlapping-intervals/dev-jonghoonpark.md @@ -0,0 +1,30 @@ +- 문제: https://leetcode.com/problems/non-overlapping-intervals/ +- 풀이: https://algorithm.jonghoonpark.com/2024/07/23/leetcode-435 + +```java +public int eraseOverlapIntervals(int[][] intervals) { + int overlappingCount = 0; + Arrays.sort(intervals, Comparator.comparingInt(o -> o[1])); + + int currentEnd = intervals[0][1]; + for (int i = 0; i < intervals.length - 1; i++) { + // overlapping 이 발생된 경우 + if (currentEnd > intervals[i + 1][0]) { + overlappingCount++; + + // 앞 interval 의 end 값이 뒤 interval 의 end 보다 작을 경우 이전 pointer 유지 + if (currentEnd < intervals[i + 1][1]) { + continue; + } + } + + currentEnd = intervals[i + 1][1]; + } + + return overlappingCount; +} +``` + +### TC, SC + +시간 복잡도는 `O(n*logn)` 공간 복잡도는 `O(1)` 이다. From f39de4c69fe2feeb27e8f8f81eaef7c812d4f8c8 Mon Sep 17 00:00:00 2001 From: jonghoonpark Date: Tue, 23 Jul 2024 04:52:19 +0900 Subject: [PATCH 2/5] week13 mission meeting-rooms-ii --- meeting-rooms-ii/dev-jonghoonpark.md | 61 ++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 meeting-rooms-ii/dev-jonghoonpark.md diff --git a/meeting-rooms-ii/dev-jonghoonpark.md b/meeting-rooms-ii/dev-jonghoonpark.md new file mode 100644 index 000000000..ee9b1f71e --- /dev/null +++ b/meeting-rooms-ii/dev-jonghoonpark.md @@ -0,0 +1,61 @@ +- 문제 + - 유료: https://leetcode.com/problems/meeting-rooms-ii/ + - 무료: https://www.lintcode.com/problem/919/ +- 풀이: https://algorithm.jonghoonpark.com/2024/07/22/leetcode-253 + +```java +public class Solution { + public int minMeetingRooms(List intervals) { + intervals = intervals.stream().sorted(Comparator.comparingInt(o -> o.start)).toList(); + + List> days = new ArrayList<>(); + + for(Interval interval : intervals) { + boolean added = false; + for (List day : days) { + day.add(interval); + if (canAttendMeetings(day)) { + added = true; + break; + } + day.remove(day.size() - 1); + } + + if(!added) { + List newDay = new ArrayList<>(); + newDay.add(interval); + days.add(newDay); + } + } + + return days.size(); + } + + public boolean canAttendMeetings(List intervals) { + for (int i = 0; i < intervals.size() - 1; i++) { + if(intervals.get(i).end > intervals.get(i+1).start) { + return false; + } + } + return true; + } +} + +class Interval { + public int start, end; + + public Interval(int start, int end) { + this.start = start; + this.end = end; + } + + @Override + public String toString() { + return "{" + start + ", " + end + "}"; + } +} +``` + +### TC, SC + +days의 길이를 m 이라고 했을 때, 시간 복잡도는 `O(n^2 * m)` 공간 복잡도는 `O(n)` 이다. m은 최악의 경우 n이 될 수 있다. From 202dbd7eb760f0dbf6dadd55c8584c7903ac3b9d Mon Sep 17 00:00:00 2001 From: jonghoonpark Date: Tue, 23 Jul 2024 04:57:55 +0900 Subject: [PATCH 3/5] week13 mission rotate-image --- rotate-image/dev-jonghoonpark.md | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 rotate-image/dev-jonghoonpark.md diff --git a/rotate-image/dev-jonghoonpark.md b/rotate-image/dev-jonghoonpark.md new file mode 100644 index 000000000..f7f8f13bc --- /dev/null +++ b/rotate-image/dev-jonghoonpark.md @@ -0,0 +1,25 @@ +- 문제: https://leetcode.com/problems/rotate-image/ +- 풀이: https://algorithm.jonghoonpark.com/2024/07/22/leetcode-48 + +```java +class Solution { + public void rotate(int[][] matrix) { + int l = matrix.length; + + int limit = (int) Math.ceil((double) l / 2); + for (int i = 0; i < limit; i++) { + for (int j = i; j < l - 1 - i; j++) { + int temp = matrix[i][j]; + matrix[i][j] = matrix[l - j - 1][i]; + matrix[l - j - 1][i] = matrix[l - i - 1][l - j - 1]; + matrix[l - i - 1][l - j - 1] = matrix[j][l - i - 1]; + matrix[j][l - i - 1] = temp; + } + } + } +} +``` + +### TC, SC + +시간 복잡도는 `O(n^2)` 공간 복잡도는 `O(1)` 이다. From b8d42fd92b99581ff16ab5b4af158367c075005f Mon Sep 17 00:00:00 2001 From: jonghoonpark Date: Tue, 23 Jul 2024 11:30:47 +0900 Subject: [PATCH 4/5] week13 mission merge-intervals --- merge-intervals/dev-jonghoonpark.md | 34 +++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 merge-intervals/dev-jonghoonpark.md diff --git a/merge-intervals/dev-jonghoonpark.md b/merge-intervals/dev-jonghoonpark.md new file mode 100644 index 000000000..d0889dfaf --- /dev/null +++ b/merge-intervals/dev-jonghoonpark.md @@ -0,0 +1,34 @@ +- 문제: https://leetcode.com/problems/merge-intervals/ +- 풀이: https://algorithm.jonghoonpark.com/2024/07/23/leetcode-56 + +```java +class Solution { + public int[][] merge(int[][] intervals) { + Arrays.sort(intervals, Comparator.comparingInt(o -> o[0])); + + Deque intervalDeque = new ArrayDeque<>(); + intervalDeque.add(intervals[0]); + for(int i = 1; i < intervals.length; i++) { + int[] lastElement = intervalDeque.getLast(); + int[] nextElement = intervals[i]; + + if (lastElement[1] >= nextElement[0]) { + int[] mergedElement = new int[]{ + lastElement[0], + Math.max(lastElement[1], nextElement[1]) + }; + intervalDeque.removeLast(); + intervalDeque.add(mergedElement); + } else { + intervalDeque.add(nextElement); + } + } + + return intervalDeque.toArray(int[][]::new); + } +} +``` + +### TC, SC + +시간 복잡도는 `O(n*logn)` 공간 복잡도는 `O(n)` 이다. (결과를 반환하기 위해 생성된 `int[][]`는 고려하지 않는다.) From 418c17679cad33dc74d7a95f0d30da55eead18c2 Mon Sep 17 00:00:00 2001 From: jonghoonpark Date: Tue, 23 Jul 2024 13:13:40 +0900 Subject: [PATCH 5/5] week13 mission insert-interval --- insert-interval/dev-jonghoonpark.md | 101 ++++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 insert-interval/dev-jonghoonpark.md diff --git a/insert-interval/dev-jonghoonpark.md b/insert-interval/dev-jonghoonpark.md new file mode 100644 index 000000000..ec2518e0e --- /dev/null +++ b/insert-interval/dev-jonghoonpark.md @@ -0,0 +1,101 @@ +- 문제: https://leetcode.com/problems/insert-interval/ +- 풀이: https://algorithm.jonghoonpark.com/2024/02/14/leetcode-57 + +## Merge Intervals 문제 답안 응용하기 + +바로 전에 풀었던 [Merge Intervals](https://algorithm.jonghoonpark.com/2024/07/23/leetcode-56)를 그대로 가져다 쓸 수 있을 것 같아서 해보았더니 통과 된다. + +```java +public int[][] insert(int[][] intervals, int[] newInterval) { + int[][] newIntervals = Arrays.copyOf(intervals, intervals.length + 1); + newIntervals[intervals.length] = newInterval; + return merge(newIntervals); +} + +public int[][] merge(int[][] intervals) { + Arrays.sort(intervals, Comparator.comparingInt(o -> o[0])); + + Deque intervalDeque = new ArrayDeque<>(); + intervalDeque.add(intervals[0]); + for(int i = 1; i < intervals.length; i++) { + int[] lastElement = intervalDeque.getLast(); + int[] nextElement = intervals[i]; + + if (lastElement[1] >= nextElement[0]) { + int[] mergedElement = new int[]{ + lastElement[0], + Math.max(lastElement[1], nextElement[1]) + }; + intervalDeque.removeLast(); + intervalDeque.add(mergedElement); + } else { + intervalDeque.add(nextElement); + } + } + + return intervalDeque.toArray(int[][]::new); +} +``` + +### TC, SC + +시간 복잡도는 `O(n*logn)` 공간 복잡도는 `O(n)` 이다. (결과를 반환하기 위해 생성된 `int[][]`는 고려하지 않는다.) + +## 성능을 개선한 답안 (pointer 사용) + +문제를 잘 읽어보면 intervals 의 경우 start를 기준으로 이미 정렬이 되어있다고 하였기 떄문에 따로 정렬을 해줄 필요는 없다. +for loop 에서는 start, end pointer를 이용해서 어느 구간이 병합되는지 기억해두고, 최종적으로 병합을 진행한다. + +start 가 -1 인 경우는 맨 오른쪽에 추가가 되어야 한다는 의미이고 +end 가 -1 인 경우는 맨 왼쪽에 추가가되어야 한다는 의미이다. +그 외에는 병합이 발생한 것이므로 병합처리를 진행한다. + +```java +class Solution { + public int[][] insert(int[][] intervals, int[] newInterval) { + int start = -1; + int end = -1; + + for (int i = 0; i < intervals.length; i++) { + if (start == -1 && intervals[i][1] >= newInterval[0]) { + start = i; + } + + if (newInterval[1] >= intervals[i][0]) { + end = i; + } + } + + if (start == -1) { + int[][] newIntervals = Arrays.copyOf(intervals, intervals.length + 1); + newIntervals[intervals.length] = newInterval; + return newIntervals; + } + + if (end == -1) { + int[][] newIntervals = new int[intervals.length + 1][2]; + newIntervals[0] = newInterval; + System.arraycopy(intervals, 0, newIntervals, 1, newIntervals.length - 1); + return newIntervals; + } + + int[][] newIntervals = new int[intervals.length - (end - start)][2]; + + if (start >= 0) { + System.arraycopy(intervals, 0, newIntervals, 0, start); + } + + newIntervals[start] = new int[]{Math.min(intervals[start][0], newInterval[0]), Math.max(intervals[end][1], newInterval[1])}; + + if (intervals.length - (end + 1) >= 0) { + System.arraycopy(intervals, end + 1, newIntervals, end + 1 - (end - start), intervals.length - (end + 1)); + } + + return newIntervals; + } +} +``` + +#### TC, SC + +시간 복잡도는 `O(n)` 공간 복잡도는 `O(1)` 이다. (결과를 반환하기 위해 생성된 `int[][]`는 고려하지 않는다.)