[백준 9019] DSLR

 시간 초과를 넘기지 않도록 주의하여 구현해야 하는 BFS 문제이다.

 주어진 시간이 짧지는 않지만 (6초)

 queue <int, string> 식으로 구현을 하면, 문제 특성상 string이 복사가 일어난다.

 따라서 어마어마한 시간이 지연이 될 수 있다.  (저는 그랬어요 ㅠ)


시간을 줄이기 위해서, 가급적 if문과 배열을 사용하였고, vector <int, char> 컨테이너를 사용하여 탐색을 진행

하였다.



주의해야 할 점은, 시작 루트(from)에서 도착 루트(to)로 향할 때

순서대로 필요한 명령어를 출력해야 하기 때문에



시간 복잡도 상,  시작 -> 도착 순으로 하나씩 검색을 하면 Big-O 표기법으로 제곱 혹은 그 이상이다.

                      ( 애초에 BFS 접근을 하기 때문에 도착하기 전에는 어디가 최단거리인지 알 수가 없다)

                                                    ( 즉, 미리 저장이 불가능하다 )


그래서 도착 -> 시작으로 뒤부터 찾아가야 하는데

도착 위치에서 그 이전의 인덱스를 기억하기 위한 vector <int(이전 인덱스), char(필요했던 명령어)>를 사용

하였다.


그리고, 출력은 사용했던 명령어 순서이기 때문에, 정답의 string 값을 reverse(역 출력)을 꼭 해줘야 한다.

출처 : https://www.acmicpc.net/problem/9019

문제

네 개의 명령어 D, S, L, R 을 이용하는 간단한 계산기가 있다. 이 계산기에는 레지스터가 하나 있는데, 이 레지스터에는 0 이상 10,000 미만의 십진수를 저장할 수 있다. 각 명령어는 이 레지스터에 저장된 n을 다음과 같이 변환한다. n의 네 자릿수를 d₁, d₂, d₃, d₄라고 하자(즉 n = ((d₁ × 10 + d₂) × 10 + d₃) × 10 + d₄라고 하자)

1. D: D 는 n을 두 배로 바꾼다. 결과 값이 9999 보다 큰 경우에는 10000 으로 나눈 나머지를 취한다. 그 결과 값(2n mod 10000)을 레지스터에 저장한다.
2. S: S 는 n에서 1 을 뺀 결과 n-1을 레지스터에 저장한다. n이 0 이라면 9999 가 대신 레지스터에 저장된다.
3. L: L 은 n의 각 자릿수를 왼편으로 회전시켜 그 결과를 레지스터에 저장한다. 이 연산이 끝나면 레지스터에 저장된 네 자릿수는 왼편부터 d₂, d₃, d₄, d₁이 된다.
4. R: R 은 n의 각 자릿수를 오른편으로 회전시켜 그 결과를 레지스터에 저장한다. 이 연산이 끝나면 레지스터에 저장된 네 자릿수는 왼편부터 d₄, d₁, d₂, d₃이 된다.

위에서 언급한 것처럼, L 과 R 명령어는 십진 자릿수를 가정하고 연산을 수행한다. 예를 들어서 n = 1234 라면 여기에 L 을 적용하면 2341 이 되고 R 을 적용하면 4123 이 된다.

여러분이 작성할 프로그램은 주어진 서로 다른 두 정수 A와 B(A ≠ B)에 대하여 A를 B로 바꾸는 최소한의 명령어를 생성하는 프로그램이다. 예를 들어서 A = 1234, B = 3412 라면 다음과 같이 두 개의 명령어를 적용하면 A를 B로 변환할 수 있다.

1234 →_L 2341 →_L 3412
1234 →_R 4123 →_R 3412

따라서 여러분의 프로그램은 이 경우에 LL 이나 RR 을 출력해야 한다.

n의 자릿수로 0 이 포함된 경우에 주의해야 한다. 예를 들어서 1000 에 L 을 적용하면 0001 이 되므로 결과는 1 이 된다. 그러나 R 을 적용하면 0100 이 되므로 결과는 100 이 된다.

입력

프로그램 입력은 T 개의 테스트 케이스로 구성된다. 테스트 케이스 개수 T 는 입력의 첫 줄에 주어진다. 각 테스트 케이스로는 두 개의 정수 A와 B(A ≠ B)가 공백으로 분리되어 차례로 주어지는데 A는 레지스터의 초기 값을 나타내고 B는 최종 값을 나타낸다. A 와 B는 모두 0 이상 10,000 미만이다.

출력

A에서 B로 변환하기 위해 필요한 최소한의 명령어 나열을 출력한다.

예제 입력 1

3
1234 3412
1000 1
1 16

예제 출력 1

LL
L
DDDD

소스코드

#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>
#include<string>
 
using namespace std;
 
/*
    D: D 는 n을 두 배로 바꾼다. 결과 값이 9999 보다 큰 경우에는 10000 으로 나눈 나머지를 취한다. 그 결과 값(2n mod 10000)을 레지스터에 저장한다.
    S: S 는 n에서 1 을 뺀 결과 n-1을 레지스터에 저장한다. n이 0 이라면 9999 가 대신 레지스터에 저장된다.
    L: L 은 n의 각 자릿수를 왼편으로 회전시켜 그 결과를 레지스터에 저장한다. 이 연산이 끝나면 레지스터에 저장된 네 자릿수는 왼편부터 d2, d3, d4, d1이 된다.
    R: R 은 n의 각 자릿수를 오른편으로 회전시켜 그 결과를 레지스터에 저장한다. 이 연산이 끝나면 레지스터에 저장된 네 자릿수는 왼편부터 d4, d1, d2, d3이 된다.
*/
 
// 시작 from은 vector[from] = <-1, 'E'> 형태로 저장이 되어 있다. 
// 각각의 컨테이너는 vector[current] = <이전경로, '이동에 사용한 명령'>의 값을 가진다. 
 
vector<pair<int, char> > cmd(10000);
bool visit[10000];
queue<int> q;
string ans = "";
 
// swap을 사용한 큐 비우기 
void clearQueue(queue<int> &Queue)
{
    queue<int> empty;
    swap(Queue, empty);
}
 
// 사용한 명령어 출력하기 
void print(int next) {
    while (1) {
        char c = cmd[next].second;
        next = cmd[next].first;
        if(next == -1)
            return;
        ans += c;
    }
}
 
// 명령어 D 
int cmd_D(int a) {
    return (2 * a) % 10000;
}
 
// 명령어 S 
int cmd_S(int a) {
    if (a == 0)
        return 9999;
    else
        return a - 1;
}
 
// 명령어 L 
int cmd_L(int a) {
    return (a % 1000) * 10 + (a / 1000);
}
 
// 명령어 R 
int cmd_R(int a) {
    return (a % 10) * 1000 + (a / 10);
}
 
// 간선 비용이 '1' 이기에 
// 최소 루트를 찾기 위한 BFS 탐색 
void bfs(int from, int to) {
    q.push(from);
    visit[from] = true;
    while (!q.empty()) {
        int now, next;
        now = q.front();
        q.pop();
        for (int i = 0; i < 4; i++) {
            if (i == 0) {
                next = cmd_D(now);
                if(!visit[next])
                    cmd[next] = (make_pair(now, 'D'));
            }
            else if (i == 1) {
                next = cmd_S(now);
                if(!visit[next])
                    cmd[next] = (make_pair(now, 'S'));
            }
            else if (i == 2) {
                next = cmd_L(now);
                if(!visit[next])
                    cmd[next] = (make_pair(now, 'L'));
            }
            else if (i == 3) {
                next = cmd_R(now);
                if(!visit[next])
                    cmd[next] = (make_pair(now, 'R'));
            }
            if (next == to) {
                print(next);
                return;
            }
            if(!visit[next]){
                visit[next] = true;
                q.push(next);
            }
        }
    }
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    
    int t;
    cin >> t;
    while (t--) {
        ans = "";
        int from, to;
        cin >> from >> to;
        cmd[from] = (make_pair(-1, 'E'));                // 시작 포인트 표시 
        bfs(from, to);
        reverse(ans.begin(), ans.end());                // 도착 지점에서 탐색했기 때문에 역 출력 
        cout << ans << '\n';
        memset(visit, false, sizeof(visit));
        cmd.clear();
        clearQueue(q);
    }
    return 0;
}

※ 본 글은 개인 포트폴리오 혹은 공부용으로 사용하기 때문에, 무단 복사 유포는 금지하지만, 개인 공부 용도로는 얼마든지 사용하셔도 좋습니다.