코테/lvl2

프로그래머스 거리두기 확인하기(lvl2) 풀어보기

디비드킴 2026. 9. 15. 18:49

문제링크

https://school.programmers.co.kr/learn/courses/30/lessons/81302

 

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr


문제 핵심

문제가너무길다


문제 풀이법

-각 교실별로 분배

각교실별 p,x좌표 저장

p좌표 맨해튼거리 2이하인거 걸러내기

맨해튼x놔야할 좌표모음 만들기

해당교실에 x좌표가 필요 맨해튼 x충족하는지 확인


코드

    public static int[] solution(String[][] places) {
        int[] answer = new int[places.length];
        Map<Integer, Map<String, List<String[]>>> px = new LinkedHashMap<>();
        List<String[][]> pList = new ArrayList<>();
        int room = 0;
        for (String[] place : places) {
            String[][] placestune = new String[place.length][place[0].length()];
            List<String[]> pl = new LinkedList<>();
            List<String[]> xl = new LinkedList<>();
            int i = 0;
            for (String row : place) {
                for (int ii = 0; ii < row.length(); ii++) {
                    placestune[i][ii] = row.charAt(ii) + "";
                    if (row.charAt(ii) == 'P') {
                        pl.add(new String[] { i + "", ii + "" });
                    } else if (row.charAt(ii) == 'X') {
                        xl.add(new String[] { i + "", ii + "" });
                    }
                }
                i++;
            }
            Map<String, List<String[]>> roomMap = new LinkedHashMap<>();
            roomMap.put("p", pl);
            roomMap.put("x", xl);
            px.put(room, roomMap);
            pList.add(placestune);
            room += 1;
        }
        pList.stream()
                .forEach(arr -> {
                    Arrays.stream(arr)
                            .forEach(row -> System.out.println(Arrays.toString(row)));

                    System.out.println();
                });
        px.forEach((room1, map) -> {
            System.out.println("room1 " + room1);

            map.forEach((key, list) -> {
                System.out.println(
                        key + " = " +
                                list.stream()
                                        .map(Arrays::toString)
                                        .toList());
            });
            System.out.println();
        });
        int index = 0;
        for (Map.Entry<Integer, Map<String, List<String[]>>> entry : px.entrySet()) {
            int roomResult = 1;
            int roomn = entry.getKey();
            System.out.println("roomn:" + roomn);
            Map<String, List<String[]>> map = entry.getValue();
            List<String[]> pl = map.get("p");
            System.out.println(
                    pl.stream()
                            .map(Arrays::toString)
                            .toList());
            for (int i = 0; i < pl.size() - 1; i++) {
                for (int ii = i + 1; ii < pl.size(); ii++) {
                    String[] p1 = pl.get(i);
                    String[] p2 = pl.get(ii);
                    int r1 = Integer.parseInt(p1[0]);
                    int c1 = Integer.parseInt(p1[1]);
                    int r2 = Integer.parseInt(p2[0]);
                    int c2 = Integer.parseInt(p2[1]);
                    int sum = Math.abs(r1 - r2) + Math.abs(c1 - c2);
                    if (sum <= 2) {
                        System.out.println(
                                "맨해튼거리부족: P1=(" + r1 + "," + c1 + ")" +
                                        ", P2=(" + r2 + "," + c2 + ")" +
                                        ", 거리=" + sum);
                        if (sum == 1) {
                            System.out.println("판낼둘공간없음");
                            roomResult = 0;
                            break;
                        } else {
                            System.out.println("판낼댈수 있는지 탐색 판낼 필요위치 계산");
                            int startr = Math.min(r1, r2);
                            int endr = Math.max(r1, r2);
                            int startc = Math.min(c1, c2);
                            int endc = Math.max(c1, c2);
                            System.out.println(
                                    "x놓아야할범위 => " +
                                            "R: " + startr + " ~ " + endr +
                                            ", C: " + startc + " ~ " + endc);
                            List<String[]> xs = new LinkedList<>();
                            for (int xi = startr; xi <= endr; xi++) {
                                for (int xii = startc; xii <= endc; xii++) {
                                    if (xi + xii == r1 + c1 || xi + xii == r2 + c2) {
                                        continue;
                                    }
                                    xs.add(new String[] { xi + "", xii + "" });
                                }
                            }
                            System.out.println("x가필요한좌표: " +
                                    xs.stream()
                                            .map(Arrays::toString)
                                            .toList());
                            List<String[]> xl = map.get("x");
                            System.out.println("보유x좌표: " +
                                    xl.stream()
                                            .map(Arrays::toString)
                                            .toList());
                            int c=0;
                            for (String[] x : xs) {
                                for (String[] x2 : xl) {
                                    if (x[0].equals(x2[0]) && x[1].equals(x2[1])) {
                                        c+=1;
                                    }
                                }
                            }
                            if(xs.size()!=c){
                                System.out.println("판댈요건불충족");
                                roomResult=0;
                                break;
                            }
                        }

                    }
                }
            }
            answer[index] = roomResult;
            System.out.println("-------------------");
            index += 1;
        }
        System.out.println(Arrays.toString(answer));
       
        return answer;
    }

 


결과




gpt피드백

-

핵심 개선점

네 코드에서 제일 큰 건 이거야.

현재
places
 ↓
pList 생성
 ↓
px 생성
 ↓
P/X 다시 꺼냄
 ↓
String → int 변환
 ↓
필요 X 좌표 생성
 ↓
전체 X 좌표와 비교
 

사실은:

places
 ↓
P 좌표만 int[]로 저장
 ↓
P끼리 거리 계산
 ↓
원본 place에서 필요한 X를 바로 확인
 
 
 

배운점과느낀점

-와 너무 복잡하게 풀었다

처음에 bfs로 구현했다가 좌표나오는걸보고

어 이럴 필요도 없잖아? 하고 

줄였는데도 gpt피드백을 보니 너무 복잡하게 푼게 느껴진다