백준 1021

1번의 경우 2, 3번 방법에 해당 하지 않기 때문에 0이 출력
2번은 target index가 중간 부분보다 앞 일 경우 가장 앞 index를 뒤로 보낸후 target index가 나올 때 까지 반복한다
3번은 target index가 중간 보다 뒤 일 경우 뒤에 있는 index를 앞으로 보내 target index까지 앞으로 보내준 후 출력

import java.util.LinkedList;
import java.util.Scanner;

public class 회전하는큐1021 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        LinkedList<Integer> list = new LinkedList<>();
        int cnt = 0;

        int N = sc.nextInt();
        int M = sc.nextInt();

        for (int i = 1; i <= N; i++) {
            list.offer(i);
        }

        int[] arr = new int[M];

        for (int i = 0; i < M; i++) {
            arr[i] = sc.nextInt();
        }

        for (int i = 0; i < M; i++) {
            int target = list.indexOf(arr[i]);
            int harf_idx;

            if (list.size() % 2 == 0) {
                harf_idx = list.size() / 2 - 1;
            } else {
                harf_idx = list.size() / 2;
            }

            if (target <= harf_idx) {
                for (int j = 0; j < target; j++) {
                    int temp = list.pollFirst();
                    list.offerLast(temp);
                    cnt++;
                }
            } else {
                for (int j = 0; j < list.size() - target; j++) {
                    int temp = list.pollLast();
                    list.offerFirst(temp);
                    cnt++;
                }
            }

            list.pollFirst();

        }
        System.out.println(cnt);
    }
}
for (int i = 0; i < M; i++) {
        int target = list.indexOf(arr[i]);
        int harf_idx;

        if (list.size() % 2 == 0) {
            harf_idx = list.size() / 2 - 1;
        } else {
            harf_idx = list.size() / 2;
        }
        // 이부분이 생각이 나지 않아 결국 풀이를 참고했다.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class 회전하는큐1021_1 {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        LinkedList<Integer> deque = new LinkedList<Integer>();

        int count = 0;

        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        for(int i = 1; i <= N; i++) {
            deque.offer(i);
        }

        int[] seq = new int[M];	// M 배열

        st = new StringTokenizer(br.readLine(), " ");
        for(int i = 0; i < M; i++) {
            seq[i] = Integer.parseInt(st.nextToken());
        }


        for(int i = 0; i < M; i++) {


            // 덱에서 뽑고자 하는 숫자의 위치(index) 찾기
            int target_idx = deque.indexOf(seq[i]);
            int half_idx;
            /*
             *  만약 현재 덱의 원소가 짝수 개라면 중간 지점을
             *  현재 덱의 절반 크기에서 -1 감소시킨다.
             *
             *  {1, 2, 3, 4} 일 때, 2를 중간지점으로 하면
             *  인덱스는 1이기 때문
             */
            if(deque.size() % 2 == 0) {
                half_idx = deque.size() / 2 - 1;
            }
            else {
                half_idx = deque.size() / 2;
            }


            // 중간 지점 또는 중간 지점보다 원소의 위치가 앞에 있을 경우
            if(target_idx <= half_idx) {
                // idx 보다 앞에 있는 원소들을 모두 뒤로 보낸다. (2번 연산)
                for(int j = 0; j < target_idx; j++) {
                    int temp = deque.pollFirst();
                    deque.offerLast(temp);
                    count++;
                }
            }
            else {	// 중간 지점보다 원소의 위치가 뒤에 있는 경우
                // idx를 포함한 뒤에 있는 원소들을 모두 앞으로 보낸다. (3번 연산)
                for(int j = 0; j < deque.size() - target_idx; j++) {
                    int temp = deque.pollLast();
                    deque.offerFirst(temp);
                    count++;
                }

            }
            deque.pollFirst();	// 연산이 끝나면 맨 앞 원소를 삭제
        }

        System.out.println(count);


    }
}