8-dohyeondol1

[dohyeondol1]

🔗 문제 링크

회전하는 큐

✔️ 소요된 시간

40분

✨ 수도 코드

양방향 큐라고 볼 수 있는 '덱(deque)' 자료구조를 통해 쉽게 풀 수 있는 문제였습니다.
덱을 몰랐다 하더라도 풀 수야 있겠더라구요..

주어진 입력 순서대로 수를 뽑아내야 하기 때문에,
연산 횟수로 치지 않는 1번 연산을 이용한답시고 무작정 수를 뽑아내기만 해서는 답을 도출할 수 없습니다.

주어진 수가 덱에서 앞(왼쪽), 뒤(오른쪽) 중 어디에 더 가까운지 판별하고,
가까운 쪽으로 수를 한 칸씩 이동시켜 끝자리에서 뽑아내야 합니다.

어디에 가까운지는
덱 크기의 절반(중간지점)과, 해당 수가 위치한 인덱스의 대소 비교를 통해 판별하였습니다.
덱 크기의 절반보다 인덱스가 작다면 앞(왼쪽)에 위치한 것이고, 아니라면 뒤(오른쪽)에 위치한 것이겠죠?

이에 맞춰 연산횟수를 1씩 증가시켜 최소연산횟수를 도출하였습니다.

수도 코드

입력: 정수 N, M
입력: 길이 M의 정수 배열 target

덱 dq를 1부터 N까지로 초기화

count ← 0

for i in 0부터 M-1까지:
    현재 찾을 값 = target[i]
    dq에서 현재 값의 인덱스를 찾음

    if 인덱스 ≤ dq 크기의 절반: 
        // 왼쪽으로 한 칸씩 이동
        인덱스 횟수만큼:
            dq 앞 요소를 뒤로 보냄
            2번 연산 횟수 count 증가
    else:
        // 오른쪽으로 한 칸씩 이동
        (dq 크기 - 인덱스) 횟수만큼:
            dq 뒤 요소를 앞으로 보냄
            3번 연산 횟수 count 증가

    dq에서 맨 앞 요소 제거 (찾은 값 제거)

출력: count

📚 새롭게 알게된 내용

덱(Deque, double-ended queue)
두 개의 포인터를 사용하여, 양쪽에서 삭제와 삽입을 발생시킬 수 있습니다.

시험기간이라 PR 쓰기가 조금 빠듯하네요...그림 자료는 가능한 빨리 추가해보도록 하겠습니다..

[9kyo-hwang]

deque은 양방향 입출력이 가능하다는 것 외에도, queue와 달리 iterator 기반 연산을 지원합니다(일반 queue는 find 같은 메서드를 사용할 수 없습니다!), 그래서 [] 연산자를 통해 특정 인덱스의 원소도 바로 얻을 수 있다는 특징이 있죠.

그렇다보니 저는 어지간해선 queue보다 deque을 선호하게 되네요 :)

#include <iostream>
#include <queue>
#include <numeric>
#include <algorithm>

using namespace std;

int main()
{
    int N, M; cin >> N >> M;
    
    deque<int> DQ(N);
    iota(DQ.begin(), DQ.end(), 1);
    
    auto LeftShift = [&DQ]()
    {
        DQ.emplace_back(DQ.front());
        DQ.pop_front();
    };
    
    auto RightShift = [&DQ]()
    {
        DQ.emplace_front(DQ.back());
        DQ.pop_back();
    };
    
    int Answer = 0;
    while(M--)
    {
        int Target; cin >> Target;
        
        int Index = find(DQ.begin(), DQ.end(), Target) - DQ.begin();
        if(Index <= DQ.size() / 2)
        {
            for(; DQ.front() != Target; Answer++)
            {
                LeftShift();
            }
        }
        else
        {
            for(; DQ.front() != Target; Answer++)
            {
                RightShift();
            }
        }
        
        DQ.pop_front();
    }
    
    cout << Answer;

    return 0;
}

[9kyo-hwang]

널 값을 넘겨줄 땐 가능하면 nullptr을 사용해주세용

[dohyeondol1]

nullptr은 포인터를 명확히 나타내는군요.. nullptr을 사용하는걸 지향해야겠네욥

[9kyo-hwang]

아주 사소한 팁? 인데

#include <numeric>

deque<int> DQ(N);
iota(DQ.begin(), DQ.end(), 1);  // 1, 2, 3, ..., N - 1, N으로 DQ가 채워짐

numeric 헤더에 iota라는 함수가 있습니다. 이거를 사용하면 넘겨주는 숫자(여기서는 1)부터 1씩 증가하는 값으로 채워줍니다.

[dohyeondol1]

오호....!!!!! 사소하지만 언젠가 써먹을 팁!! 감사합니다

[9kyo-hwang]

사실 이 문제는 어떤 target값을 사용할 때, 다른 target값은 알 필요가 없기 때문에 배열에 미리 다 저장해두지 않아도 됩니다.

while(M--)
{
  int target; cin >> target;
  int index = find(dq.begin(), dq.end(), target[i]) - dq.begin();

  ...
}

이런 식으로 실시간으로 target 값을 하나씩 받을 때마다 연산을 수행하도록 코드를 작성해도 무방하죠 :)

[dohyeondol1]

그렇네요...; 나름 깎는다고 깎았는데 살짝 모자랐나 봅니다..
원래는 값을 바로 사용 가능한 경우 되도록이면 while문을 쓰는 편인데, 이번엔 알아차리지 못했네요..

[caucsejunseo]

덱은 처음 보지만 큐를 이전에 공부했어서 쉽게 접했습니다! 문제가 처음 접했을 때 풀기 좋은 문제인 거 같아요. c언어로 덱을 한 번 구현해 봤슴다.

C 코드

#define MAX 1000  // 덱 최대 크기

typedef struct {
    int data[MAX];
    int front;
    int back;
} Deque;

// 덱 초기화
void init(Deque* dq) {
    dq->front = dq->back = 0;
}

// 덱이 비었는지 확인
int isEmpty(Deque* dq) {
    return dq->front == dq->back;
}

// 덱이 가득 찼는지 확인
int isFull(Deque* dq) {
    return (dq->back + 1) % MAX == dq->front;
}

// 앞에 삽입
void push_front(Deque* dq, int x) {
    if (isFull(dq)) {
        printf("Deque is full!\n");
        return;
    }
    dq->front = (dq->front - 1 + MAX) % MAX;
    dq->data[dq->front] = x;
}

// 뒤에 삽입
void push_back(Deque* dq, int x) {
    if (isFull(dq)) {
        printf("Deque is full!\n");
        return;
    }
    dq->data[dq->back] = x;
    dq->back = (dq->back + 1) % MAX;
}

// 앞에서 제거
int pop_front(Deque* dq) {
    if (isEmpty(dq)) {
        printf("Deque is empty!\n");
        return -1;
    }
    int value = dq->data[dq->front];
    dq->front = (dq->front + 1) % MAX;
    return value;
}

// 뒤에서 제거
int pop_back(Deque* dq) {
    if (isEmpty(dq)) {
        printf("Deque is empty!\n");
        return -1;
    }
    dq->back = (dq->back - 1 + MAX) % MAX;
    return dq->data[dq->back];
}

// 앞의 값 확인
int front(Deque* dq) {
    if (isEmpty(dq)) {
        printf("Deque is empty!\n");
        return -1;
    }
    return dq->data[dq->front];
}

// 뒤의 값 확인
int back(Deque* dq) {
    if (isEmpty(dq)) {
        printf("Deque is empty!\n");
        return -1;
    }
    return dq->data[(dq->back - 1 + MAX) % MAX];
}

[froglike6]

deque를 정말 오랜만에 보는 것 같습니다.. 저는 파이썬의 rotate를 이용해 비교적 쉽게 풀어봤습니다.

파이썬

from collections import deque
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
targets = list(map(int, input().split()))
dq = deque(range(1, N+1))
ops = 0
for t in targets:
    idx = dq.index(t)
    if idx <= len(dq) - idx:
        dq.rotate(-idx)
        ops += idx
    else:
        dq.rotate(len(dq) - idx)
        ops += len(dq) - idx
    dq.popleft()
print(ops)

[dohyeondol1]

@caucsejunseo
오오 C로 덱구현..!! 저도 덱을 처음 접해서 이 문제를 가져와봤어요 ㅎㅎ
이제 시험도 끝났는데 준서님도 다른 언어로 갈아타시나요...??

[hadongun]

오우.. 파이썬에는 큐를 회전시킬 수 있는 rotate라는 게 있더군요!

생각보다 쉽지 않네요.. ! 연산 횟수를 어떻게 구해야 할까.. 에 대해서 생각이 잘 나질 않아
약간의 지피티의 도움을 받았네욥

파이떤

from collections import deque

n, m = map(int, input().split())
targets = list(map(int, input().split()))
rotationq = deque()
for i in range(1, n + 1):
    rotationq.append(i)

total_moves = 0

for target in targets:
    idx = rotationq.index(target)
    if idx <= len(rotationq) // 2:
        rotationq.rotate(-idx)
        total_moves += idx
    else: 
        rotationq.rotate(len(rotationq) - idx)
        total_moves += len(rotationq) - idx

    rotationq.popleft() 

print(total_moves)

[dohyeondol1]

@hadongun
스택과 큐에 조금 익숙해지면 덱은 자연스럽게 풀 수 있을 것 같습니다!
양방향 큐라고 생각하면, 사실 큐를 쓸 이유가 줄어들어 대부분 덱만 쓸 것 같기도 하구요 ㅋㅋ

저는 개인적으로 문제를 풀다가 아예 모르겠다 싶으면 다른 사람들의 블로그를 참고하는 편입니다..
gpt한테 다양한 풀이를 받을 수도 있겠지만,
다른 사람들이 작성한 다양한 접근 방법이나 정형화된 방법을 직접 찾아보고 접하는 편이 좀 더 재밌게 배울 수 있더라구요.
(아무래도 gpt는 쏟아부은 시간이 한순간에 아무것도 아닌게 되어버리는 것 같아서 현타가 옵니다..)

어쨌거나 이번에 배웠으니 다음에 잘 풀면 되죠! 빠빠빠이팅!