취업 준비 및 일상

제331회 TEPS

닻과매 — Tue, 27 Sep 2022 16:32:35 +0900

왜 잘 봄?

2023 KAKAO BLIND RECRUITMENT 1차

닻과매 — Sat, 24 Sep 2022 20:39:29 +0900

4시간 좀 넘어서 6문제 풀었습니다. 7번은 대충 어떤 식으로 쌓이는 지는 알겠는데, 처리를 어떻게 할지 생각이 잘 안 나더라고요.

알고리즘: 구현

난이도: 실버 하위?

알고리즘: 그리디

난이도: 골드 하위? 백준에서 비슷한 문제를 본 기억이 있습니다(링크).

알고리즘: 브루트포스, 구현

난이도: 실버 상위?

알고리즘: 트리, 애드혹

난이도: 골드 하위?

알고리즘: 빡구현, 유니온 파인드

난이도: 골드 중상위?

알고리즘: 그리디

난이도: 골드 중간?

모름! 시험 끝나고 치킨 먹으면서 생각해보니 될 거 같기도 한데, 당시에 5번 문제를 대략 10번 가량 꼴아박으며 AC를 받느라 육체적, 정신적 여력을 다 써서 그냥 바로 행복버튼(=테스트 종료) 눌렀습니다.

2문제가 그리디이고, 4번도 되게 직관적으로 풀이를 찾아야 하는 스타일의 문제였습니다. 코드포스 및 앳코더 같은 대회를 유희삼아 했었는데, 그런 거 하는 사람이 꽤나 유리할만한 문제 셋이었습니다.

그리디가 꽤 전형적이었다고 생각합니다. 그래서 풀이는 꽤 금세 찾았는데, 구현에서 좀 헤맸습니다. 프로그래머스 디버깅하기 힘들어요ㅠㅠ

참고 링크: 안즈님 풀이

확률 10000....0배 높이

닻과매 — Sat, 24 Sep 2022 12:37:33 +0900

https://youtu.be/PE4vLbyOgw0

흥미롭네요

2022년 4차 Softeer 정기 역량 진단

닻과매 — Tue, 20 Sep 2022 22:04:23 +0900

https://softeer.ai/challenge/certification/detail.do?idx=1974

Softeer

제1조 (목적) 이 약관은 현대엔지비㈜ (이하 ‘회사’)가 제공하는 Softeer 사이트의 테스트 참여에 관한 사항을 규정함을 목적으로 합니다. 제2조 (테스트 응시자의 의무) 1. 아이디와 비밀번호에

softeer.ai

지인한테 추천받은 사이트인데, 해당 사이트에서 정기 역량 진단이 있다고 해서 한번 봤습니다.

모든 문제를 푼 사람에게 Lv.3 등급 인증 자격 부여하며, 해당 등급 인증을 획득하면 현대자동차 등의 현대 계열사의 SW 분야 지원시 코딩테스트 면제라 합니다.

시험 전

공고가 뜨면 신청합니다. 선착순이라고 했는데, 이번 시험 기준으로 453명이 지원했으니 경쟁이 치열하진 않습니다.

응시 당일에 메일로 안내 사항이 옵니다. 소프티어 사이트에서 문제 1~2개 풀어보면서 환경에 적응해봅시다.

한 시험 30분 전부터 들어가면 됩니다. 핸드폰 연결, 화면 공유, 신분증 제출 등을 하면 됩니다. 인증한 이후로는 뭐 하기가 불편하니 시험 시작 전까지 적당히 들어가도 되긴 합니다.

듀얼 모니터 불가, 외부 IDE 사용 불가입니다.

시험

2문제가 출제됩니다. 시험 시간이 3시간이길래 삼성 역량테스트마냥 구현이 빡센 문제 2개를 내는 줄 알았는데, 좀 전형적인 알고리즘 문제를 냈더라고요. 이분 탐색, 누적합 등의 알고리즘을 사용하여 풀 수 있으며 실버 중상위 수준의 난이도입니다.

큰 사이즈의 테케를 넣어보고 싶었는데, 외부 IDE 등을 사용할 수 없으므로 테케를 넣는 것도 힘듭니다. 그래서 그냥 적당히 small sample size에 대해서만 확인해보고 제출했습니다. 푸는 데 25분, 검토하는데 25분 정도 걸렸네요.

다만, 문제 제출 결과는 안 알려줍니다.

개인적인 소감

요즘 코테 점점 어려워지잖아요? 카카오처럼 알고리즘/구현 양쪽 모두 어렵게 내기도 하고, 삼성처럼 구현만 매우 빡세게 내기도 합니다. 그런 와중에 꽤 전형적인 2문제 풀면 코테 면제? 현대 지원하고자 하는 사람들에게는 꽤 메리트가 있는 시험이 아닌가 싶습니다.

결과

취득 못했으면 안 올렸음ㅋㅋㅋㅋ

Tistory에 LaTex 쓰기

닻과매 — Sat, 10 Sep 2022 16:00:04 +0900

<script type="text/x-mathjax-config">
MathJax.Hub.Config({
  tex2jax: {inlineMath: [['$','$'], ['\\(','\\)']]}
});
</script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-MML-AM_CHTML"></script>

를 적으면 됩니다.

Trie 문제들

닻과매 — Wed, 7 Sep 2022 19:10:36 +0900

바킹독님이 트라이 강의를 올려서 다시 공부했습니다. 트라이 문제를 좀 풀어본 적이 있어서 복습일 줄 알았는데, 트라이 구현 방식이 달라서 좀 새로웠네요. 이 방법을 알았다면 현대모비스 알고리즘 경진대회에 나온 트라이 쓰는 2문제에서 더 높은 점수를 받을 수 있지 않았을까? 싶기도 합니다.

기존에 트라이를 블로그를 통해 공부했을 때, 다들 구현 방법으로 Trie class를 만들어 사용하는 방법을 제시하더라고요. 그리고 Trie내의 자식 노드를 구현을 1) Map<node, Trie>으로 하는 방법, 2) 적당한 크기의 Trie배열을 선언하는 방법으로 나눌 수 있었습니다.

위 강의에서는 처음부터 2차원 배열을 크게 선언한 다음 사용하라고 했는데, 처음 보니까 조금 생소하기도 하고 비효율적이다는 느낌(되게 안쓰는 칸이 많아요)을 받았는데, 문제를 좀 풀어보니까 더 빠르고, 평소에 쓰던 array 쓰는 거라 편합니다. 앞으로도 이렇게 풀 거 같아요. 다만 몇몇 문제에서는 메모리 문제가 발생할 수 있는데, 이럴 때만 class를 이용한 Map 풀이를 하면 될 듯합니다.

문제들 (링크)

11425번: 문자열 집합, 14426번:접두사 찾기

기본

5052번: 전화번호 목록

트라이에 순서대로 넣으면서 1) 기존 문자열에 완전히 포함되거나, 2) 기존 문자열을 완전히 포함하는지 확인하면 됩니다.

7432번: 디스크 트리

이차원 배열로 풀려면 각 노드를 적당한 형태의 숫자로 바꿔야 하는데, 본 문제에서는 하나의 노드가 8글자 이하의 String이기에 Trie class를 만들어 풀었습니다.

14725번: 개미굴

디스크 트리랑 비슷합니다.

16934번: 게임 닉네임

닉네임을 넣으면서, 각 닉네임별로 알파벳을 트라이에 삽입합니다. 만약 만나지 않은 노드에 도달했으면, 해당 노드의 알파벳까지만 치면 구분이 가능하기에 별칭을 거기까지만 해서 등록을 합니다. 마지막 노드에 도달했는데, 이미 해당 노드를 마지막으로 하는 경우(=같은 닉네임이 이미 등록된 경우) 그 횟수를 기록해두어(마지막임을 기록하는 배열을 boolean이 아니라 int로 하면 됩니다.) 등장횟수 + 1만큼 뒤에 붙여주어 별칭으로 만들어줍니다.

9202번: Boggle

처음에는 각 board별로 trie에 넣고, 문자열을 찾는건가 했는데 그 반대입니다. w개의 문자를 다 넣어준 후, 각 board별로 최대 길이가 8인, 길이가 8이하인 단어를 만들어 속하는지 확인해주면 됩니다. 보드에서 단어를 만드는거다보니, dfs 및 백트래킹을 활용합니다.

시간 복잡도가 어떻게 되는지 잘 모르겠네요. 그래서 (아마 가장 많은 탐색을 하지 않을까 싶은) 첨부파일과 같은 테스트케이스를 만들어서 dfs 함수의 호출 횟수를 세봤는데, 900만번도 안되더라고요. 10초 제한도 널널합니다.

그리고 dfs에서 문자를 concat하기보다 (단어 사전에 있는 단어를 완성했을 때 도달하는 숫자)와 (단어 사전 리스트의 인덱스)를 대응시켜 문자를 $ O(1) $에 찾아줍시다. 근데 보니까 그렇게 안해도 문제는 풀리는 듯합니다.

되게 재미있고, 추천할만한 문제라 느껴집니다.

16906번: 욱제어

한 단어가 다른 단어의 접두어가 되지 않도록 해야 합니다.

생각해보면 짧은 단어를 먼저 넣어야한다는 사실을 관찰할 수 있습니다. 예를 들어, 만약 00000이 들어가있는데, 길이가 3인 문자열 4개를 넣는 상황을 생각해보면 쉽지가 않습니다. 첫번째 0을 이미 방문했을테니까 100같은 문자열을 넣었다고 하면, 다음 문자열은 어디에 넣을까요? 지금 이런 상황에서야 직관적으로 101 넣으면 된다는 걸 알지만, 기존 트라이 구현에서는 첫 번째 0이든 1이든 방문했다고 나타나있을텐데 말입니다. 근데 다른 분들 코드를 보니까 정렬 안하신 분들도 있는 거 같은데, 잘 모르겠네요ㅎㅎ

그래서, 단어를 길이의 오름차순대로 넣도록 합니다. 넣을 때는 '최대한 왼쪽'에 쑤셔넣도록 합니다. 예를 들어, 길이가 2인 문자열을 4개 넣는다고 하면, 00, 01, 10, 11 순으로 넣으면 됩니다. 그래도 안 들어가면 -1을 출력하면 됩니다.

위 문제보다더 더 재미있게 풀었는데, 코테 스타일 문제는 아니긴합니다.

5670번: 휴대폰 자판

메모리 제한이 빡빡해서 이차원 배열 풀이로는 메모리 초과가 뜨네요. 최적화를 못한걸 수도 있는데, 일단은 Trie class 만들어서 하면 되니까 넘어가도록 합니다.

처음에는 무조건 눌러야 하고('p'만 있다고 바로 p가 완성되지는 않으니까요), 이후에는 해당 노드에 방문한 횟수가 1보다 크거나 현재 노드에서 끝나는 경우("abc"와 "ab"가 있고, "abc"를 검색하는 경우: 일단 a를 누르고 b가 자동완성되면 c를 눌러야한다.)에는 그 다음 글자를 눌러줘야 합니다.

5446번: 용량 부족

"...*'로 지우면 안되는 글자가 있다면, 해당 글자의 노드마다 지우면 안된다는 표시를 해둡니다.

이후 지우는데, 만약 지워도 되는 노드를 만났다면 '...(노드)*' 명령어로 지워버립니다.

지우면 안 되는 노드이지만 지워야하는 파일명의 마지막 노드라면 '...(노드)' 명령어로 지우고, 다음 노드를 살펴봅니다.

지우면 안 되는 노드이면 그냥 다음 노드로 넘어갔습니다.

트리에서 각 노드 방문을 한 번씩 하는 방식으로 구현했어서 실제로 지우진 않았습니다.

BoggleTC.txt

0.00MB

백준 10775번: 공항 (Java)

닻과매 — Tue, 6 Sep 2022 11:55:25 +0900

https://www.acmicpc.net/problem/10775

10775번: 공항

예제 1 : [2][?][?][1] 형태로 도킹시킬 수 있다. 3번째 비행기는 도킹시킬 수 없다. 예제 2 : [1][2][3][?] 형태로 도킹 시킬 수 있고, 4번째 비행기는 절대 도킹 시킬 수 없어서 이후 추가적인 도킹은 불

www.acmicpc.net

딱 보고 '이분 매칭'아니야? 라고 생각을 해서 알고리즘 태그를 까서 봤습니다. 스포당해서 제대로 푼 느낌이 아니네요. 스케줄링 유형의 문제에 약합니다.

풀이

도착한 사람이 현재 갈 수 있는 게이트 중 가장 큰 숫자로 배치시켜야 합니다. 그러려면, 현재 나온 숫자에서 거슬러 올라가면서 아직 사용하지 않은 게이트 중 가장 큰 숫자를 찾으면 됩니다.

가장 먼저 생각나는 구현 방법으로는, 적당한 boolean 배열을 만들어 !visited[$i$]일 때까지 거슬러 올라가다가, !visited[$i$]인 $i$를 찾으면 도킹시키고, 만약 $ i = 0 $이면 도킹할 수 있는 게이트가 없다는 뜻이니 중단시키는 방법일 겁니다. 다만, 이 알고리즘은 시간 복잡도가 $O(P^2)$라, $ G = 10^5, P = 10^5, G_i = 10^5$
인 경우 최대 $ 10^{10} $ 번 '언저리'의 연산을 수행하여 시간 초과가 발생합니다.

따라서, 유니온 파인드를 사용하여, (현재 게이트보다 작은 게이트 중 도킹되지 않은 가장 큰 게이트)를 현재 게이트의 조상으로 가지도록 합니다. 아이디어가 참신합니다.

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import java.io.*;
import java.util.*;
 
public class Main {
    
    static int[] p;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int G = Integer.parseInt(br.readLine());
        int P = Integer.parseInt(br.readLine());
        makeSet(G);
        int cnt = 0;
        for (int i = 0; i < P; i++) {
            int cur = Integer.parseInt(br.readLine());
            int loc = findRoot(cur);
            if (loc == 0) break;
            union(loc-1, loc);
            cnt++;
        }
        System.out.println(cnt);
    }
    
    static void makeSet(int N) {
        p = new int[N + 1];
        for (int i = 0; i <= N; i++) {
            p[i] = i;
        }
    }
 
    static int findRoot(int a) {
        if (a == p[a])
            return a;
        return p[a] = findRoot(p[a]);
    }
 
    static boolean union(int a, int b) {
        a = findRoot(a);
        b = findRoot(b);
        if (a == b) return false;
        p[b] = a;
        return true;
    }
}
 
Colored by Color Scripter

cs

2022 신촌지역 대학생 프로그래밍 대회 동아리 연합 여름 대회 (SUAPC 2022 Summer) Open Contest

닻과매 — Mon, 5 Sep 2022 22:17:03 +0900

https://www.acmicpc.net/contest/view/849

2022 신촌지역 대학생 프로그래밍 대회 동아리 연합 여름 대회 (SUAPC 2022 Summer) Open Contest

www.acmicpc.net

6문제 풀었습니다. 생각보다 잘한 듯?

수학적인 사고력을 요하는 문제가 많네요.

, ,

double 이차원 배열 dp를 다음과 같이 정의합시다:

$dp[l][k]$ = (최솟값이 $0$, 최댓값이 $l$인 구간에서 $k$를 찾는 기댓값)

경우의 수를 적당히 잘 나누어주어 기댓값을 저장합니다.

시간 복잡도는 O($2400^2$ + $N$)입니다.

그냥 구현

C
$N \leq 10^6$이라는 건 (아마) $O(N^2)$ 풀이가 안 된다는 거고, 딱히 정렬을 하는 방식을 사용할 거 같지 않으므로 $ O(NlogN) $ 풀이도 아닐 겁니다. 그러므로, $ O(N) $ 시간 복잡도를 갖는, 적당한 방법을 직관적으로 찾기를 요구하는 문제인 듯합니다.

일단 $N$이 적혀있는 카드는 가장 먼저 뽑아야 합니다: 안 그러면 $N$을 적혀있는 카드를 뽑는 사람은 패스를 2번 이상 받게 됩니다. 이후 생각이 잘 안 나서, $N \leq 12$에 대해서 브루트포스로 찍어보니, $N$이 짝수일 때만 정답이 구해지더라고요. 그래서 일단 짝수일때만 가능하다고 생각하고 풀었습니다. 풀고나서 생각해보니, $N$이 $3$ 이상의 홀수일 때

$\sum_{n=1}^{N-1} n = \frac{N(N-1)}{2} \equiv 0 (mod N)$ 이기에, 처음 시작하는 사람은 무조건 2번 이상 패스를 받습니다.

$N$이 짝수일 때 처음 시작점을 1이라고 한다면, $2 \to N-1 \to 3 \to N-2 \to ...$ 에게 패스를 하면 된다는 사실을 관찰할 수 있습니다. '직관적인 관찰'이라 어떻게 생각했는지 모르겠네요.

그리고 $N$이 홀수라도 $N=1$일 때는 됩니다. 이 경우만 예외처리해주면 됩니다.

일반성을 잃지 않고, $A_1, ... A_N$을 $A_1 < A_2 < ... < A_N$로 정합시다.

차의 개수의 최댓값

$A_i = 2^{i-1}$로 설정하면 차이의 개수는 $N(N-1)/2$개로 최대입니다. $2^{29} < 10$억이라 가능합니다.

차의 개수의 최솟값

그리고 간단히 $A_i = i$로 결정하면 차의 개수가 $N-1$개가 됩니다.

좀 디버깅이 끔찍한 case-work 문제입니다. 일단, 케이스를 좀 편하게 나누기 위해 row, col별로 씨앗의 개수를 세주고, 씨앗이 있는 row, col의 수, 그리고 씨앗이 뿌려져있는 칸의 수를 세줍니다.

1) 만약 씨앗이 뿌려져있는 칸의 수가 $2K$개라면 겹쳐서 씨앗을 뿌리지 않았으므로 $-1$ 출력

2) 1)이 아니라면: $2K$ - '씨앗이 뿌려져있는 칸의 수'개만큼 씨앗을 겹쳐뿌렸습니다. case를 나누어,

I) 씨앗이 있는 row의 수가 1인 경우: 두 명 모두 한 줄에 겹쳐 뿌렸다는 뜻입니다. 몇 개가 겹쳤는지 '씨앗이 뿌려져있는 칸의 수'를 통해 구하고, '겹칠 수밖에 없는' 위치의 씨앗의 좌표를 저장해 출력합니다.

II) 씨앗이 있는 col의 수가 1인 경우: I)이랑 row/col 바꿔서 풀면 됩니다.

III) 그외: 한 명은 세로로, 한 명은 가로로 씨앗을 뿌렸습니다. 이 경우 최대 1곳에서만 만나며, 위 정보를 통해 빠르게 구해줍니다.

$K=1$일 때의 예외 처리를 해줘야할 거 같지만, 2) - I)에서 잘 처리가 됩니다.

그와 별개로 실수하기 참 쉬운 문제입니다. 저는 한 곳에서만 $N, M$을 바꿔썼다가 디버깅이 엄청 오래 걸렸습니다.

주제별로 뽑을 수 있는 경우의 수를 $X_i$라고 하면, 정답 $X = \prod_{i=1}^{N} X_{i}$ 이고,

$X_i= \sum_{n=1}^{N} \binom{A_i}{n} \binom{B_i}{n}$ where $N = min(A_i, B_i)$ 입니다.

그리고

$X_i= \sum_{n=1}^{N} \binom{A_i}{n} \binom{B_i}{n} = \binom{A_i+B_i}{N} - 1 $

이 됩니다. 이는

$(1+x)^{A_i+B_i} = (1+x)^{A_i}(1+x)^{B_i}$의 $N$차항의 계수를 비교하면 알 수 있습니다. 찾아보니 Vandermonde's Identity라고 합니다. 수학 전공한거 맞나? ㅋㅋ... 잘 모르겠어서 구글에 대충 쳐서 구했습니다.

그리고, 오일러 소정리를 이용하면, 임의의 소수 $p$에 대해,

$\binom{A_i+B_i}{A_i} \equiv \frac{(A_i+B_i)!}{A_i!B_i!} \equiv (A_i+B_i)!(A_i)!^{p-2}(B_i)!^{p-2} (mod p)$

가 성립합니다. 본 문제에서 $p = 10^{9}+7$입니다.

$1!$ 부터 $(A+B)!$을 미리 구하고, 분할정복을 이용하여 $p$제곱을 계산하기에, 각 쿼리를 $O(logp)$에 처리할 수 있습니다. 시작 복잡도는 $O((A+B) + Nlogp)$.

글 정리하겠다고 학부 시절에는 쳐다도 안 봤던 LaTex 문법을 다 써보네요ㅋㅋ

생각보다 쓰는 방법이 간단해서, 시간 복잡도 '$ O(N) $' 정도의 표현에 대해서는 계속 써야겠습니다.

LCA를 O(logN)에 구하기 - Sparse Table

닻과매 — Sun, 4 Sep 2022 23:35:13 +0900

코테 수준에서 이거? 알 필요 없습니다. 근데 백준 11437번: LCA를 멍청한 구현으로 풀고 나니 살짝 허무해서, 개념을 공부하고 문제를 좀 풀어봤습니다.

개념

한 마디로 'Sparse Table'이라는 자료 구조에 각 노드의 (2의 제곱번째) 조상'들'을 저장하여 (처리 과정 O(NlogN)), 이후 LCA를 O(logN)에 구할 수 있도록 하는 방법입니다. Q번의 LCA를 찾는 과정을 naive한 풀이는 O(NQ)의 시간 복잡도 내에 수행하나, sparse table을 이용하면 O((N+Q)logN) 시간 복잡도 내에 수행할 수 있습니다.

parent[cur][i] = parent[parent[cur][i-1]][i-1]의 의미를 잘 알아두면 나중 구현할 때 기억하기 좋을 듯합니다.

자세한 설명은 라이 블로그를 참고하세요.

문제

배운 거 그대로 쓰면 됩니다.

배운 거 그대로 쓰면 됩니다.

두 정점 u, v의 lca가 w라면, 두 노드 사이의 거리는 dist[u] + dist[v] - 2*dist[w]가 됩니다.

백준 3176번: 도로 네트워크

다른 sparse table 2개를 더 만들어, 구간에서의 최댓값/최솟값을 저장해주면 됩니다.

백준 13511번: 트리와 쿼리 2

1) 비용 출력 -> 1761번이랑 동일합니다.

2) k번째 정점 출력 -> 정점 u, v 사이에 있는 정점의 수를 구한 후, u에서 올라가서 찾을 수 있는 경우와 v에서 올라가서 찾을 수 있는 경우를 나누어 처리합니다.

백준 1525번: 퍼즐 (Java)

닻과매 — Sun, 4 Sep 2022 22:29:40 +0900

https://www.acmicpc.net/problem/1525

1525번: 퍼즐

세 줄에 걸쳐서 표에 채워져 있는 아홉 개의 수가 주어진다. 한 줄에 세 개의 수가 주어지며, 빈 칸은 0으로 나타낸다.

www.acmicpc.net

풀이

처음 보면 꽤 막막합니다. 케이스를 잘 나누어 각 경우마다 최적의 움직임을 수행하면 될까? 일단 케이스를 분류하는거조차 모르겠고, 각 상황별 최적의 움직임이 뭔지도 모르겠네요. 이 방법은 아닌 듯 합니다.

한 단계의 움직임을 분석해보니까, 0을 (가능한 방향의) 사방의 숫자랑 바꾸는 것이고, 이는 사방 탐색으로 구현할 수 있어 보입니다. 거기에다가 특정 상태에 가장 먼저 도착...? => BFS로 될 겁니다.

그러면, 상태 공간을 저장할 배열을 만들어야 할 겁니다. 가장 간단한 방법은 각 칸의 크기가 9인 9차원(!) 배열을 만들어, 각각의 칸의 숫자랑 대응시킬 수 있을 겁니다. 다만 int 9^9개 배열을 선언하면 문제의 메모리 제한에 걸릴 겁니다.

즉, 상태를 조금 더 간단하게 나타내어 32MB 이내로 모든 상태를 저장할 수 있도록 해야합니다. 생각해보면 0~8사이의 수는 1칸에 딱 한 번만 들어가야 하기에, 경우의 수는 9! = 362880가지가 될 거고, 이 경우만 저장한다면 메모리 초과가 발생하지 않을 겁니다.

방법이야 다양하게 있겠지만, 저는 좌측 상단부터 우측 하단까지의 숫자를 쭉 적은 방법으로 상태를 저장했습니다. 가령, '예제 입력 1'의 상태를 103425786이라는 정수로 대응시키는 거죠. 이를 Map에 <상태, 이동 횟수>를 저장하여 각 상태별로 최적의 이동회수를 저장했습니다.

참고로, 상태를 "103425787"과 같은 String으로 저장할 수도 있으나, 1)String 관련 내장함수를 잘 몰라서, 2)각종 String manipulation(concat, replace 등...)이 죄다 O(N) 시간복잡도라 사용하지 않았습니다. 근데 다른 분들 풀이 보면 String으로 상태를 저장해도 (살짝 느리지만) 시간 내에 잘 되더라고요.

이후 0을 움직여주면 됩니다. 처리가 살짝 지저분한데, 어려운 건 아니니 적당히 해줍시다.

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

import java.io.*;
import java.util.*;
 
public class Main {
    static int[] dr = { -1, 1, 0, 0 };
    static int[] dc = { 0, 0, -1, 1 };
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[][] locToidx = new int[][] {{2, 2}, {2, 1}, {2, 0}, {1, 2}, {1, 1}, {1, 0}, {0, 2}, {0, 1}, {0, 0}};
        int[][] idxToloc = new int[][] {{8, 7, 6}, {5, 4, 3}, {2, 1, 0}};
        int first = 0;
        int zero = 0;
        for (int i = 0; i < 3; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < 3; j++) {
                first *= 10;
                int temp = Integer.parseInt(st.nextToken());
                first += temp;
                if (temp == 0) {
                    zero = idxToloc[i][j];
                }
            }
        }
        HashMap<Integer, Integer> memo = new HashMap<>();
        memo.put(first, 0);
        Queue<Info> queue = new ArrayDeque<>();
        queue.offer(new Info(zero, first));
        while (!queue.isEmpty()) {
            Info cur = queue.poll();
            int[] idx = locToidx[cur.zeroLoc];
            int r = idx[0], c = idx[1];
            for (int i = 0; i < 4; i++) {
                int nr = r + dr[i], nc = c + dc[i];
                if (nr < 0 || nr >= 3 || nc < 0 || nc >= 3) continue;
                int nxtzeroLoc = idxToloc[nr][nc];
                int num = cur.status;
                for (int j = 0; j < nxtzeroLoc; j++) {
                    num /= 10;
                }
                num %= 10;
                int nxtStatus = cur.status + num * (int) Math.pow(10, cur.zeroLoc) - num * (int) Math.pow(10, nxtzeroLoc);
                if (memo.containsKey(nxtStatus)) continue;
                memo.put(nxtStatus, memo.get(cur.status) + 1);
                queue.offer(new Info(nxtzeroLoc, nxtStatus));
            }
        }
        if (!memo.containsKey(123456780)) System.out.println(-1);
        else System.out.println(memo.get(123456780));
    }
    
    static class Info {
        int zeroLoc;
        int status;
        
        public Info(int zeroLoc, int status) {
            this.zeroLoc = zeroLoc;
            this.status = status;
        }
    }
}
 
Colored by Color Scripter

cs