30주차 (#26)

Author: J-MU

src/main/java/org/example/_30week/CctvProblem.java

@@ -0,0 +1,170 @@
+package org.example._30week;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+
+public class CctvProblem {
+
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+    private static int[][] map;
+    private static List<CCTV> cctvs;
+    private static int rowSize;
+    private static int colSize;
+    private static int emptySize;
+
+    private static final int WALL = 6;
+
+    private static int[] dr = {-1, 0, 1, 0};
+    private static int[] dc = {0, 1, 0, -1};
+
+    private static int blindSpotSize = Integer.MAX_VALUE;
+
+    public static void main(String[] args) throws IOException {
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        rowSize = Integer.parseInt(st.nextToken());
+        colSize = Integer.parseInt(st.nextToken());
+        emptySize = 0;
+
+        map = new int[rowSize][colSize];
+        cctvs = new ArrayList<>();
+
+        for (int row = 0; row < rowSize; row++) {
+            st = new StringTokenizer(br.readLine());
+            for (int col = 0; col < colSize; col++) {
+                map[row][col] = Integer.parseInt(st.nextToken());
+                if (map[row][col] == 0) {
+                    emptySize++;
+                } else if (map[row][col] >= 1 && map[row][col] <= 5) {
+                    cctvs.add(new CCTV(row, col, map[row][col]));
+                }
+            }
+        }
+
+        boolean[][] flags = new boolean[rowSize][colSize];
+        dfs(0, 0, flags);
+
+        System.out.println(blindSpotSize);
+    }
+
+    private static void dfs(int index, int count, boolean[][] flags) {
+        if (cctvs.size() == index) {
+            blindSpotSize = Math.min(blindSpotSize, emptySize - count);
+            return;
+        }
+
+        CCTV cctv = cctvs.get(index);
+        for (int[] direction : cctv.directions()) {
+            boolean[][] newFlags = copyFlags(flags);
+            int tempCount = count;
+            for (int dir : direction) {
+                int row = cctv.row;
+                int col = cctv.col;
+
+                while (true) {
+                    row = row + dr[dir];
+                    col = col + dc[dir];
+
+                    if (row < 0 || row >= rowSize || col < 0 || col >= colSize) {
+                        break;
+                    }
+
+                    if (map[row][col] == WALL) {
+                        break;
+                    }
+
+                    if (map[row][col] >= 1 && map[row][col] <= 5) {
+                        continue;
+                    }
+
+                    if (newFlags[row][col]) {
+                        continue;
+                    }
+
+                    newFlags[row][col] = true;
+                    tempCount++;
+                }
+            }
+
+            dfs(index + 1, tempCount, newFlags);
+        }
+    }
+
+    private static boolean[][] copyFlags(boolean[][] flags) {
+        boolean[][] newFlags = new boolean[rowSize][colSize];
+
+        for (int row = 0; row < rowSize; row++) {
+            for (int col = 0; col < colSize; col++) {
+                newFlags[row][col] = flags[row][col];
+            }
+        }
+
+        return newFlags;
+    }
+
+    private static class CCTV {
+        private static final int[][] one = {{0}, {1}, {2}, {3}};
+        private static final int[][] two = {{0, 2}, {1, 3}};
+        private static final int[][] three = {{0, 1}, {1, 2}, {2, 3}, {3, 0}};
+        private static final int[][] four = {{3, 0, 1}, {0, 1, 2}, {1, 2, 3}, {2, 3, 0}};
+        private static final int[][] five = {{0, 1, 2, 3}};
+
+        int row;
+        int col;
+        int no;
+
+        public CCTV(int row, int col, int no) {
+            this.row = row;
+            this.col = col;
+            this.no = no;
+        }
+
+        @Override
+        public String toString() {
+            return "CCTV{" +
+                    "row=" + row +
+                    ", col=" + col +
+                    ", no=" + no +
+                    '}';
+        }
+
+        public int[][] directions() {
+            switch (no) {
+                case 1:
+                    return one;
+                case 2:
+                    return two;
+                case 3:
+                    return three;
+                case 4:
+                    return four;
+                case 5:
+                    return five;
+                default:
+                    return null;
+            }
+        }
+
+        public int directionSize() {
+            switch (no) {
+                case 1:
+                    return one.length;
+                case 2:
+                    return two.length;
+                case 3:
+                    return three.length;
+                case 4:
+                    return four.length;
+                case 5:
+                    return five.length;
+                default:
+                    return 0;
+            }
+        }
+    }
+
+}

src/main/java/org/example/_30week/DoYouWannaBuildASnowman.java

@@ -0,0 +1,72 @@
+package org.example._30week;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class DoYouWannaBuildASnowman {
+
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static int[] numbers;
+
+    private static int answer = Integer.MAX_VALUE;
+
+    public static void main(String[] args) throws IOException {
+        int N = Integer.parseInt(br.readLine());
+        numbers = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
+
+        List<Snowman> snowmen = new ArrayList<>(180_000);
+
+        for (int i = 0; i < N; i++) {
+            for (int j = i + 1; j < N; j++) {
+                snowmen.add(new Snowman(i, j));
+            }
+        }
+
+        Collections.sort(snowmen);
+
+        int snowmanSize = snowmen.size();
+        for (int target = 0; target < snowmanSize; target++) {
+            Snowman targetSnowman = snowmen.get(target);
+
+            for (int i = target + 1; i < snowmanSize; i++) {
+                Snowman snowman = snowmen.get(i);
+
+                boolean hasDuplication = targetSnowman.hasDuplication(snowman);
+                if (!hasDuplication) {
+                    answer = Math.min(answer, Math.abs(targetSnowman.getSize() - snowman.getSize()));
+                    break;
+                }
+            }
+        }
+
+        System.out.println(answer);
+    }
+
+    private static class Snowman implements Comparable<Snowman> {
+        int x;
+        int y;
+        int sum;
+
+        public Snowman(int x, int y) {
+            this.x = x;
+            this.y = y;
+            this.sum = numbers[x] + numbers[y];
+        }
+
+        public boolean hasDuplication(Snowman other) {
+            return other.x == this.x || other.x == this.y || other.y == this.x || other.y == this.y;
+        }
+
+        public int getSize() {
+            return numbers[x] + numbers[y];
+        }
+
+        @Override
+        public int compareTo(Snowman o) {
+            return Integer.compare(this.sum, o.sum);
+        }
+    }
+
+}

src/main/java/org/example/_30week/LongestCommonPrefix.java

@@ -0,0 +1,33 @@
+package org.example._30week;
+
+import java.util.Arrays;
+
+public class LongestCommonPrefix {
+
+    public static void main(String[] args) {
+//        String[] strs = {"flower", "flow", "flight"};
+        String[] strs = {"dog", "racecar", "car"};
+
+        String prefix = longestCommonPrefix(strs);
+        System.out.println(prefix);
+    }
+
+    public static String longestCommonPrefix(String[] strs) {
+        int minLength = Arrays.stream(strs).mapToInt(String::length).min().getAsInt();
+
+        StringBuilder prefix = new StringBuilder();
+        for (int index = 0; index < minLength; index++) {
+            char ch = strs[0].charAt(index);
+
+            for (int i = 0; i < strs.length; i++) {
+                if (strs[i].charAt(index) != ch) {
+                    return prefix.toString();
+                }
+            }
+
+            prefix.append(ch);
+        }
+
+        return prefix.toString();
+    }
+}

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

@@ -0,0 +1,56 @@
+package org.example._30week;
+
+import java.util.*;
+
+class MergeIntervals {
+    private static Set<Integer> zeroIntervals;
+
+    public int[][] merge(int[][] intervals) {
+        List<int[]> answers = new ArrayList<>();
+        zeroIntervals = new HashSet<>();
+        int[] checkPoints = new int[10_001];
+
+        for (int[] interval : intervals) {
+            if (interval[0] == interval[1]) {
+                zeroIntervals.add(interval[0]);
+                continue;
+            }
+
+            checkPoints[interval[0]]++;
+            checkPoints[interval[1]]--;
+        }
+
+//        for (int i = 0; i < 19; i++) {
+//            System.out.print(checkPoints[i]+" ");
+//        }
+//        System.out.println();
+
+        int startCount = 0;
+        int startIndex = 0;
+        for (int i = 0; i < 10_001; i++) {
+            int value = checkPoints[i];
+
+            if (value > 0) {
+                if (startCount == 0) {
+                    startIndex = i;
+                }
+                startCount += value;
+            } else if (value < 0) {
+                startCount += value;
+                if (startCount == 0) {
+                    answers.add(new int[]{startIndex, i});
+                }
+            } else {
+                if (startCount == 0) {
+                    boolean contains = zeroIntervals.contains(i);
+
+                    if (contains) {
+                        answers.add(new int[]{i, i});
+                    }
+                }
+            }
+        }
+
+        return answers.stream().toArray(int[][]::new);
+    }
+}

src/main/java/org/example/_30week/RemoveDuplicatesFromSortedArray.java

@@ -0,0 +1,30 @@
+package org.example._30week;
+
+import java.util.Arrays;
+
+public class RemoveDuplicatesFromSortedArray {
+
+    public static void main(String[] args) {
+//        int[] nums = {1, 1, 2};
+        int[] nums = {0, 0, 1, 1, 1, 2, 2, 3, 3, 4};
+
+        int answer = removeDuplicates(nums);
+        System.out.println("size = " + answer);
+        Arrays.stream(nums).forEach(e -> System.out.print(e + ", "));
+    }
+
+    public static int removeDuplicates(int[] nums) {
+        int index = 0;
+        int prev = 1000;
+
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] != prev) {
+                nums[index] = nums[i];
+                index++;
+                prev = nums[i];
+            }
+        }
+
+        return index;
+    }
+}