[0901] 60060번 - 가사 검색

src/programmers/gilbut/ch11_datastructure/Q60060.java

@@ -0,0 +1,44 @@
+package programmers.gilbut.ch11_datastructure;
+
+import java.util.*;
+
+// 메모리 초과
+class Q60060 {
+    public int[] solution(String[] words, String[] queries) {
+        int[] answer = new int[queries.length];
+
+        HashMap<String, Integer> map = new HashMap<>();
+        for(String word: words){
+            for(int i=0;i<word.length();i++){
+                String str = word.substring(0,i+1)+String.valueOf(word.length()-i-1);
+                map.put(str,map.getOrDefault(str,0)+1);
+
+                str = String.valueOf(word.length()-i-1)+word.substring(word.length()-i-1);
+                map.put(str,map.getOrDefault(str,0)+1);
+            }
+        }
+
+        for(int i=0;i<queries.length;i++){
+            String query = queries[i];
+
+            int start = query.indexOf('?');
+            int end = query.lastIndexOf('?');
+            int length = end-start+1;
+
+            String queryStr = "";
+            // 접두사일 경우
+            if(start == 0){
+                queryStr = String.valueOf(length)+query.substring(end+1);
+            }
+
+            // 접미사일 경우
+            else if(end == query.length()-1){
+                queryStr = query.substring(0,start)+String.valueOf(length);
+            }
+
+            answer[i] = map.getOrDefault(queryStr,0);
+        }
+
+        return answer;
+    }
+}

src/programmers/gilbut/ch11_datastructure/Q60060_2.java

@@ -0,0 +1,102 @@
+package programmers.gilbut.ch11_datastructure;
+
+import java.util.*;
+
+class Q60060_2 {
+
+    HashMap<Integer,List<String>> map = new HashMap<>();
+    HashMap<Integer,List<String>> reverseMap = new HashMap<>();
+
+    public int[] solution(String[] words, String[] queries) {
+        int[] answer = new int[queries.length];
+
+        // 길이별로 단어 저장
+        for(String word: words){
+            int len = word.length();
+
+            map.computeIfAbsent(len, k->new ArrayList<>())
+                    .add(word);
+
+            String reverseWord = new StringBuilder(word).reverse().toString();
+            reverseMap.computeIfAbsent(len, k->new ArrayList<>())
+                    .add(reverseWord);
+        }
+
+        // 길이별 정렬
+        for(List<String> list: map.values()){
+            Collections.sort(list);
+        }
+        for(List<String> list: reverseMap.values()){
+            Collections.sort(list);
+        }
+
+        for(int i=0;i<queries.length;i++){
+            String query = queries[i];
+            int len = query.length();
+
+            List<String> list;
+
+            // 접두사일 경우
+            if(query.charAt(0) == '?'){
+                query = new StringBuilder(query).reverse().toString();
+                list = reverseMap.get(len);
+            }
+            // 접미사일 경우
+            else{
+                list = map.get(len);
+            }
+
+            if(list == null){
+                answer[i] = 0;
+                continue;
+            }
+
+            String min = query.replace('?','a');
+            String max = query.replace('?','z');
+
+            int start = lowerBound(list,min);
+            int end = upperBound(list,max);
+
+            answer[i] = end-start;
+        }
+
+        return answer;
+    }
+
+    // target 이상이 처음 나오는 위치
+    int lowerBound(List<String> list, String target){
+        int left = 0;
+        int right = list.size()-1;
+
+        while(left<=right){
+            int mid = (left+right)/2;
+
+            if(list.get(mid).compareTo(target)>=0){
+                right = mid-1;
+            }
+            else{
+                left = mid+1;
+            }
+        }
+
+        return left;
+    }
+    // target 초과가 처음 나오는 위치
+    int upperBound(List<String> list, String target){
+        int left = 0;
+        int right = list.size()-1;
+
+        while(left<=right){
+            int mid = (left+right)/2;
+
+            if(list.get(mid).compareTo(target)>0){
+                right = mid-1;
+            }
+            else{
+                left = mid+1;
+            }
+        }
+
+        return left;
+    }
+}

src/programmers/gilbut/ch12_implementation/Q42884.java

@@ -0,0 +1,35 @@
+package programmers.gilbut.ch12_implementation;
+
+import java.util.*;
+
+class Q42884 {
+    public int solution(int[][] routes) {
+        int answer = 0;
+
+        Arrays.sort(routes,(a,b)->a[0]-b[0]);
+
+        int count = 1;
+        int s1 = routes[0][0]; // -20
+        int e1 = routes[0][1]; // -15
+        for(int i=1;i<routes.length;i++){
+            int[] route = routes[i];
+            int s2 = route[0];
+            int e2 = route[1];
+
+            // 겹치지 않으면 카메라 개수++
+            if(e1 < s2){
+                count++;
+                s1 = s2;
+                e1 = e2;
+            }
+
+            else{
+                s1 = Math.max(s1,s2);
+                e1 = Math.min(e1,e2);
+            }
+
+        }
+
+        return count;
+    }
+}

src/programmers/gilbut/ch13_kakao/Q92342.java

@@ -0,0 +1,74 @@
+package programmers.gilbut.ch13_kakao;
+
+class Q92342 {
+    static int N;
+    static int[] Info;
+    static int max;
+    static int[] answer = new int[11];
+    public int[] solution(int n, int[] info) {
+        N = n;
+        Info = info;
+        max = Integer.MIN_VALUE;
+
+        int[] lion = new int[11];
+        dfs(0,0,lion);
+
+        if(max == Integer.MIN_VALUE){
+            return new int[]{-1};
+        }
+        return answer;
+    }
+
+    static void dfs(int index, int count, int[] lion){
+        if(count > N){
+            return;
+        }
+        if(index == 11){
+            // 화살 남은거 다 0점에 몰아줌
+            lion[10] += N-count;
+
+            int apeachGrade = 0;
+            int lionGrade = 0;
+            for(int j=0;j<10;j++){
+                if(Info[j] >= lion[j] && Info[j] != 0){
+                    apeachGrade += 10-j;
+                }
+                else if(Info[j] < lion[j]){
+                    lionGrade += 10-j;
+                }
+            }
+
+            int diff = lionGrade-apeachGrade;
+            if(diff>0){
+                // 점수차 더 큰거
+                if(diff>max){
+                    max = diff;
+                    answer = lion.clone();
+                }
+
+                // 점수차 같으면 낮은 점수가 더 많은 거
+                else if(diff==max){
+                    for(int i=10;i>=0;i--){
+                        if(lion[i] > answer[i]){
+                            answer = lion.clone();
+                            break;
+                        }
+                        else if(lion[i] < answer[i]){
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return;
+        }
+
+        // 라이언 승
+        lion[index] = Info[index]+1;
+        dfs(index+1,count+lion[index],lion);
+
+        // 라이언 포기
+        lion[index] = 0;
+        dfs(index+1,count,lion);
+    }
+}