방문 길이_복습

2026.08.07

문제 풀이

1차 실행 오류

---

10/100

실패

---

실패 원인 분석

for (int j = 0; j < reversedArr.length; j++) {
	reversedArr[j] = arr[arr.length - j - 1];
}

에서 잘못된 인덱스 값을 넣고 있던 것이 원인

---

import java.util.Set;
import java.util.HashSet;
import java.util.Arrays;

class Solution {
    public int solution(String dirs) {
        int x = 0;
        int y = 0;
        int[] before = new int[2];
        int[] after = new int[2];
        int[] arr = new int[4];
        int[] reversedArr = new int[4];
        Set<String> set = new HashSet<>();
        
        for (int i = 0; i < dirs.length(); i++) {
            before[0] = x;
            before[1] = y;
            char dir = dirs.charAt(i);
            
            switch(dir) {
                case 'L': {
                    x = (x > -5 ? x - 1 : -5);
                    break;
                }
                case 'R': {
                    x = (x < 5 ? x + 1 : 5);
                    break;
                }
                case 'U': {
                    y = (y < 5 ? y + 1 : 5);
                    break;
                }
                case 'D': {
                    y = (y > -5 ? y - 1 : -5);
                    break;
                }
            }
            after[0] = x;
            after[1] = y;
            arr[0] = before[0];
            arr[1] = before[1];
            arr[2] = after[0];
            arr[3] = after[1];
            
            for (int j = 0; j < reversedArr.length; j++) {
                reversedArr[j] = arr[arr.length - j - 1];
            }
            
            if (arr[0] == arr[2] && arr[1] == arr[3]) {
                continue;
            }
            set.add(Arrays.toString(arr));
            set.add(Arrays.toString(reversedArr));
        }
        return set.size() / 2;
    }
}

나의 코드

---

소요 시간: 59분
시간 복잡도: $O(N)$

---

import java.util.Set;
import java.util.HashSet;
import java.util.Arrays;

class Solution {
    public int solution(String dirs) {
        int x = 0;
        int y = 0;
        int[] before = new int[2];
        int[] after = new int[2];
        int[] arr = new int[4];
        int[] reversedArr = new int[4];
        Set<String> set = new HashSet<>();
        
        for (int i = 0; i < dirs.length(); i++) {
            before[0] = x;
            before[1] = y;
            char dir = dirs.charAt(i);
            
            switch(dir) {
                case 'L': {
                    x = (x > -5 ? x - 1 : -5);
                    break;
                }
                case 'R': {
                    x = (x < 5 ? x + 1 : 5);
                    break;
                }
                case 'U': {
                    y = (y < 5 ? y + 1 : 5);
                    break;
                }
                case 'D': {
                    y = (y > -5 ? y - 1 : -5);
                    break;
                }
            }
            after[0] = x;
            after[1] = y;
            arr[0] = before[0];
            arr[1] = before[1];
            arr[2] = after[0];
            arr[3] = after[1];
            
            reversedArr[0] = arr[2];
            reversedArr[1] = arr[3];
            reversedArr[2] = arr[0];
            reversedArr[3] = arr[1];
            
            if (arr[0] == arr[2] && arr[1] == arr[3]) { // 이동하지 않았을 때
                continue;
            }
            set.add(Arrays.toString(arr));
            set.add(Arrays.toString(reversedArr));
        }
        return set.size() / 2;
    }
}

AI 코드

---

시간 복잡도: $O(N)$

---

코드 분석

로직 자체는 나의 코드와 유사하다.

그러나 Set에 저장할 때에는 바로 문자열 형태로 만들어서 저장하기 때문에
arr[], reversedArr[]를 사용할 필요가 없다.

before[], after[] 또한 배열이 아닌 변수를 그대로 사용하고,
값의 비교 없이 해당 값이 이탈했는지 하지 않았는지만을 판별한다.

---

import java.util.HashSet;
import java.util.Set;

class Solution {
    public int solution(String dirs) {
        Set<String> visited = new HashSet<>();
        int x = 0;
        int y = 0;

        for (char c : dirs.toCharArray()) {
            int nx = x;
            int ny = y;

            switch (c) {
                case 'U' -> ny++;
                case 'D' -> ny--;
                case 'L' -> nx--;
                case 'R' -> nx++;
            }

            if (nx < -5 || nx > 5 || ny < -5 || ny > 5) continue; // 좌표 평면 이탈

            // 같은 길을 양방향으로 저장 → 왕복해도 1개로 취급
            visited.add(x + "," + y + "," + nx + "," + ny);
            visited.add(nx + "," + ny + "," + x + "," + y);

            x = nx;
            y = ny;
        }

        return visited.size() / 2;
    }
}

문제 풀이 후기

이미 풀어봐서 익숙한 문제라 그런지 모르겠지만, 전체적인 코드 구조에 대한 알고리즘을 짜는 데에는 큰 어려움이 없다.

그러나 코드가 너무 난잡하다는 문제가 있다.
AI 코드처럼 개선의 여지가 분명함에도 문제점을 인식하지 못하고 있다.

잘 짜여진 코드들을 보면서 나의 코드가 어느 부분이 개선 여지가 있는지
판단할 수 있는 눈을 길러야 한다.