48주차

Author: J-MU

src/main/java/org/example/_48week/CrossStones.java

@@ -0,0 +1,48 @@
+package org.example._48week;
+
+public class CrossStones {
+
+    public static void main(String[] args) {
+        int[] stones = {2, 4, 5, 3, 2, 1, 4, 2, 5, 1};
+        int k = 3;
+
+        System.out.println(solution(stones, k));
+    }
+
+    public static int solution(int[] stones, int k) {
+        int s = 0;
+        int e = 200_000_000;// 2억
+
+        // O(NlogN)
+        while (s < e) {
+            int mid = s + (e - s) / 2;
+
+            if (isPassable(stones, mid,k)) {
+                s = mid + 1;
+            } else {
+                e = mid;
+            }
+        }
+
+        return s;
+    }
+
+    // O(N)
+    private static boolean isPassable(int[] stones, int peopleCnt, int k) {
+
+        int cnt = 0;
+        for (int i = 0; i < stones.length; i++) {
+            if (stones[i] > peopleCnt) {
+                cnt=0;
+                continue;
+            }
+
+            cnt++;
+            if (cnt == k) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/org/example/_48week/LockAndKey.java

@@ -0,0 +1,92 @@
+package org.example._48week;
+
+class LockAndKey {
+    private static int N = 0;
+    private static int M = 0;
+
+    public static void main(String[] args) {
+        int[][] key = {{0, 0, 0}, {1, 0, 0}, {0, 1, 1}};
+        int[][] lock = {{1, 1, 1}, {1, 1, 0}, {1, 0, 1}};
+
+        boolean solution = solution(key, lock);
+        System.out.println(solution);
+    }
+    public static boolean solution(int[][] key, int[][] lock) {
+        N = lock.length;
+        M = key.length;
+
+        int[][][] keys = makeRotationKeys(key);
+        int[][] newLock = makeExtensionLock(lock);
+
+        for (int row = 0; row < newLock.length; row++) {
+            for (int col = 0; col < newLock.length; col++) {
+                for (int rotation = 0; rotation < 4; rotation++) {
+                    boolean isMatch = isMatch(keys[rotation], newLock, row, col);
+                    if (isMatch) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public static int[][][] makeRotationKeys(int[][] key) {
+        int[][][] keys = new int[4][M][M];
+        keys[0] = key;
+
+        for (int i = 1; i < 4; i++) {
+            for (int row = 0; row < key.length; row++) {
+                for (int col = 0; col < key[0].length; col++) {
+                    keys[i][col][key.length-1-row] = keys[i - 1][row][col];
+                }
+            }
+        }
+
+        return keys;
+    }
+
+    private static int[][] makeExtensionLock(int[][] lock) {
+        int newLength = N + 2 * M - 2;
+        int[][] newLock = new int[newLength][newLength];
+
+        for (int row = 0; row < newLength; row++) {
+            for (int col = 0; col < newLength; col++) {
+                newLock[row][col] = 3;
+            }
+        }
+
+        for (int row = M - 1, originalRow = 0; row < M - 1 + N; row++, originalRow++) {
+            for (int col = M - 1, originalCol = 0; col < M - 1 + N; col++, originalCol++) {
+                newLock[row][col] = lock[originalRow][originalCol];
+            }
+        }
+
+        return newLock;
+    }
+
+    public static boolean isMatch(int[][] key, int[][] lock, int rowIndex, int colIndex) {
+        for (int row = M - 1; row < M - 1 + N; row++) {
+            for (int col = M - 1; col < M - 1 + N; col++) {
+                if (((row - rowIndex) < 0 || (row - rowIndex) >= M) || ((col - colIndex) < 0 || (col - colIndex) >= M)){
+                    if(lock[row][col]==0){
+                        return false;
+                    }
+
+                    continue;
+                }
+
+                if (lock[row][col] == 0 && key[row - rowIndex][col - colIndex] == 0) {
+                    return false;
+                }
+
+                if (lock[row][col] == 1 && key[row - rowIndex][col - colIndex] == 1) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/org/example/_48week/MergeIntervals.java

@@ -0,0 +1,42 @@
+package org.example._48week;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+public class MergeIntervals {
+
+    private static final int s = 0;
+    private static final int e = 1;
+
+    public static void main(String[] args) {
+//        int[][] intervals = {{1, 3}, {2, 6}, {8, 10}, {15, 18}};
+        int[][] intervals = {{1, 4}, {2, 3}};
+        int[][] answer = merge(intervals);
+        System.out.println("end");
+    }
+
+    public static int[][] merge(int[][] intervals) {
+        Arrays.sort(intervals, Comparator.comparingInt((int[] a) -> a[s]));
+        List<int[]> newIntervals = new ArrayList<>();
+
+        int lastStart = intervals[0][s];
+        int lastEnd = intervals[0][e];
+
+        for (int i = 1; i < intervals.length; i++) {
+            if (lastEnd >= intervals[i][s]) {
+                lastEnd = Math.max(lastEnd, intervals[i][e]);
+                continue;
+            }
+
+            newIntervals.add(new int[]{lastStart, lastEnd});
+            lastStart = intervals[i][s];
+            lastEnd = intervals[i][e];
+        }
+
+        newIntervals.add(new int[]{lastStart, lastEnd});
+        return newIntervals.stream()
+                .toArray(int[][]::new);
+    }
+}

src/main/java/org/example/_48week/SharedTaxiFare.java

@@ -0,0 +1,74 @@
+package org.example._48week;
+
+public class SharedTaxiFare {
+
+    private static final int INF = 100_000_000; // 1억
+
+    public static void main(String[] args) {
+//        int n = 6;
+//        int s = 4;
+//        int a = 6;
+//        int b = 2;
+//        int[][] fares = {{4, 1, 10}, {3, 5, 24}, {5, 6, 2}, {3, 1, 41}, {5, 1, 24}, {4, 6, 50}, {2, 4, 66}, {2, 3, 22}, {1, 6, 25}};
+
+        int n = 7;
+        int s = 3;
+        int a = 4;
+        int b = 1;
+        int[][] fares = {{5, 7, 9}, {4, 6, 4}, {3, 6, 1}, {3, 2, 3}, {2, 1, 6}};
+
+        int solution = solution(n, s, a, b, fares);
+        System.out.println(solution);
+    }
+
+    // n: node개수
+    // s: 시작 지점
+    // a: A의 도착 지점
+    // b: B의 도착 지점
+    // fares: 지점 사이의 예상 택시 요금
+    public static int solution(int n, int s, int a, int b, int[][] fares) {
+        // make dp
+        int[][] dp = initMap(n, fares);
+
+        // floyd warshall O(N^3)
+        for (int k = 1; k < n + 1; k++) {
+            for (int row = 1; row < n + 1; row++) {
+                for (int col = 1; col < n + 1; col++) {
+                    dp[row][col] = Math.min(dp[row][col], dp[row][k] + dp[k][col]);
+                }
+            }
+        }
+
+        int answer = Integer.MAX_VALUE;
+        for (int i = 1; i < n + 1; i++) {
+            answer = Math.min(answer, dp[s][i] + dp[i][a] + dp[i][b]);
+        }
+
+        return answer;
+    }
+
+    private static int[][] initMap(int n, int[][] fares) {
+        int[][] dp = new int[n + 1][n + 1];
+
+        for (int row = 1; row < n + 1; row++) {
+            for (int col = 1; col < n + 1; col++) {
+                if (row == col) {
+                    dp[row][col] = 0;
+                } else {
+                    dp[row][col] = INF;
+                }
+            }
+        }
+
+        for (int[] fare : fares) {
+            int node1 = fare[0];
+            int node2 = fare[1];
+            int cost = fare[2];
+
+            dp[node1][node2] = cost;
+            dp[node2][node1] = cost;
+        }
+
+        return dp;
+    }
+}

src/main/java/org/example/_48week/ShuttleBus.java

@@ -0,0 +1,77 @@
+package org.example._48week;
+
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class ShuttleBus {
+
+    public static void main(String[] args) {
+        String[] arr = {"09:10", "09:09", "08:00"};
+        String answer = solution(2,10,2, arr);
+
+        System.out.println(answer);
+    }
+
+    // n: 셔틀 운행 횟수
+    // t: 셔틀 운행 간격
+    // m: 한 셔틀에 탈 수 있는 최대 크루원 수
+    public static String solution(int n, int t, int m, String[] timetable) {
+        Bus[] busses = new Bus[n];
+        boolean[] full = new boolean[n];
+
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm");
+        LocalDateTime currentTime = LocalDateTime.now()
+                .withHour(9)
+                .withMinute(0)
+                .withSecond(0)
+                .minusMinutes(t);
+
+        Arrays.sort(timetable);
+
+        // busses 초기화
+        for (int busIdx = 0; busIdx < n; busIdx++) {
+            currentTime = currentTime.plusMinutes(t);
+            busses[busIdx] = new Bus(currentTime.format(formatter));
+        }
+
+        for (int timeIdx = 0, busIdx = 0; timeIdx < timetable.length && busIdx < n; timeIdx++) {
+            if (timetable[timeIdx].compareTo(busses[busIdx].time) > 0) {
+                busIdx++;
+                timeIdx--;
+                continue;
+            }
+
+            busses[busIdx].cnt++;
+            if (busses[busIdx].cnt >= m) {
+                full[busIdx] = true;
+                busIdx++;
+            }
+        }
+
+        for (int busIdx = busses.length - 1; busIdx >= 0; busIdx--) {
+            if (!full[busIdx]) {
+                return busses[busIdx].time;
+            }
+        }
+
+        LocalDateTime dateTime = LocalDateTime.of(
+                LocalDateTime.now().toLocalDate(), // 오늘 날짜 가져오기
+                LocalTime.parse(timetable[m-2], formatter) // 문자열을 LocalTime으로 변환
+        );
+
+        return dateTime.minusMinutes(1).format(formatter);
+    }
+
+    private static class Bus {
+        String time;
+        int cnt;
+
+        public Bus(String time) {
+            this.time = time;
+            this.cnt = 0;
+        }
+    }
+}