문제 바로가기

나의 풀이

처음에는 쉽게 봤다가 예외 처리에 애먹은 문제이다.

나는 list를 두개 만들어두고 (삭제해야하므로 배열 안씀)

• 음수는 left에 (넣어줄 때는 절대값으로)
• 양수는 right에 넣었다

여기서 중요한데 두개를 각각 sort한 다음, 각각에서 제일 멀리 있는 원소를 비교해야한다.

그런데 여기서 두개의 list 중 하나는 값이 없는 경우도 있을 것이다.

따라서

1. left와 right 중에 최소 사이즈 값을 구한다
2. 최소 사이즈 값이 0이면 사이즈가 0이 아닌 부분만 고려한다!
3. 최소 사이즈 값이 0이 아니면 원소들을 큰 순서부터 시작해서 하나씩 비교해야한다. (가장 멀리있는 원소들은 값이 같으면 그 다음 멀리있는 원소가 있는 곳을 마지막에 방문하도록 해야한다)

함수의 경우

• lastMove() : 마지막에는 원점으로 돌아오지 않아도 된다. 가장 멀리 있는 곳에 가면서 m개를 들고 가야한다.
• roundTrip() : m개를 들고 다니면서 책을 꽂은 후에는 다시 원점으로 돌아와야한다.

세세한 코드에 대한 설명은 이만 줄이겠다..

코드에 리팩토링할 부분이 많은 점은 이해바랍니다!

---

나의 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

class Main {

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        List<Integer> left = new ArrayList<>();
        List<Integer> right = new ArrayList<>();

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            int place = Integer.parseInt(st.nextToken());
            if (place < 0) {
                left.add(Math.abs(place));
            } else {
                right.add(place);
            }
        }

        int answer = 0;
        Collections.sort(left);
        Collections.sort(right);

        int minSize = Math.min(left.size(), right.size());

        if (minSize != 0) {
            boolean leftFirst = true;
            for (int i = 0; i < minSize; i++) {
                if (left.get(left.size() - i - 1) == right.get(right.size() - i - 1)) {
                    continue;
                } else if (left.get(left.size() - i - 1) < right.get(right.size() - i - 1)) {
                    leftFirst = false;
                    break;
                } else {
                    leftFirst = true;
                    break;
                }
            }
            if (leftFirst) {
                answer = lastMove(left, m, answer);
            } else {
                answer = lastMove(right, m, answer);
            }
            answer = roundTrip(left, m, answer);
            answer = roundTrip(right, m, answer);
        } else {
            if (left.size() == 0) {
                answer = lastMove(right, m, answer);
                answer = roundTrip(right, m, answer);
            } else {
                answer = lastMove(left, m, answer);
                answer = roundTrip(left, m, answer);
            }
        }

        System.out.println(answer);
    }

    private static int roundTrip(List<Integer> list, int m, int answer) {
        while (!list.isEmpty()) {
            answer += list.get(list.size() - 1) * 2;
            remove(list, m);
        }
        return answer;
    }

    private static int lastMove(List<Integer> list, int m, int answer) {
        answer += list.get(list.size() - 1);
        remove(list, m);
        return answer;
    }

    private static void remove(List<Integer> list, int m) {
        for (int i = 0; i < m; i++) {
            if (list.isEmpty())
                return;
            list.remove(list.size() - 1);
        }
    }
}