15662 - 톱니바퀴(2)

 

---

 

문제

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

 

풀이

우선 바퀴는 LinkedList 에 저장함으로 회전이 쉽도록 구성했다. 

(가장 앞쪽에 있는걸 뒤로하거나, 그 반대로 함에 따라 시계방향, 반시계방향 회전 구현이 가능하다.)

 

이후

 

나는 현재 바퀴를 기준으로, 

 

앞쪽에 돌아가야하는 바퀴들을 검사하고

 

뒤쪽에 돌아가야하는 바퀴들을 검사하는 방식으로 수행했다.

 

이 때 포인터를 두개둬서, 기준점하고 그 기준점 앞의 바퀴를 가리키도록 했다.

그 다음에 극이 같은지 다른지 검사하고, 이 과정을 앞쪽으로 쭉 반복, 뒤쪽으로 쭉 반복하는 식으로 구성했다.

 

검사 결과에 따라 돌아가야하는 바퀴들은 Map에 <바퀴번호, 방향> 방식으로 저장해서 한 번 회전이 끝났을때

Map에서 값을 꺼내서 회전을 시키는 방식으로 구성했다. 검사할때마다 회전을 해버리면 다음 값과 검사하기가 힘들기 때문에 모든 바퀴의 회전 유무를 파악한다음에 돌리는 방식으로 수행했다.

 

 

코드

import java.util.*;
import java.io.*;

public class Main {

    public static  List<LinkedList<String>> gears = new ArrayList<>();

    public void solution() throws Exception {

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

        int t = Integer.parseInt(br.readLine());
        int answer = 0;
        
        // 톱니는 Linked List 형태로 관리한다.
        for (int i = 0; i < t; i++) {
            gears.add(new LinkedList<>(Arrays.asList(br.readLine().split(""))));
        }

        int cycleCount = Integer.parseInt(br.readLine());

        // cycleCount 만큼 수행한다.
        for (int i = 0; i < cycleCount; i++) {
            Map<Integer, Integer> map = new HashMap<>();

            StringTokenizer st = new StringTokenizer(br.readLine());
            int targetGear = Integer.parseInt(st.nextToken()) - 1;
            int direction = Integer.parseInt(st.nextToken());

            int frontPointer = targetGear;
            int frontDirection = direction;
            int backPointer = targetGear;
            int backDirection = direction;

            map.put(targetGear, direction);

            // 내 앞쪽의 바퀴가 돌아가야하는지를 검사한다.
            while(frontPointer > 0){

                String currentValue = gears.get(frontPointer).get(6);
                String frontValue = gears.get(frontPointer - 1).get(2);

                // 만약 같다면, 이제 회전시킬일이 없음.
                if(currentValue.equals(frontValue)) {
                    break;
                }

                // 다르다면 변경시켜준다.
                frontDirection = changeDirection(frontDirection);

                // 해당 톱니가 돌아가야할 정보를 저장한다.
                map.put(frontPointer - 1, frontDirection);
                frontPointer--;
            }

            // 내 뒤쪽의 바퀴가 돌아가야하는지를 검사한다.
            while(backPointer < t-1){

                String currentValue = gears.get(backPointer).get(2);
                String frontValue = gears.get(backPointer + 1).get(6);

                // 만약 같다면, 이제 회전시킬일이 없음.
                if(currentValue.equals(frontValue)) {
                    break;
                }

                // 다르다면 변경시켜준다.
                backDirection = changeDirection(backDirection);

                // 해당 톱니가 돌아가야할 정보를 저장한다.
                map.put(backPointer + 1, backDirection);
                backPointer++;
            }

            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
                int gearNumber = entry.getKey();
                int gearDirection = entry.getValue();

                cycle(gearNumber, gearDirection);
            }
        }

        for (LinkedList<String> gear : gears) {
            if(gear.get(0).equals("1")) answer++;
        }

        System.out.println(answer);

    }


    public void cycle(int idx, int direction){
        if(direction == 1){ // 시계 방향
            LinkedList<String> strings = gears.get(idx);
            strings.addFirst(strings.removeLast());
        }

        if(direction == -1){ // 반 시계 방향
            LinkedList<String> strings = gears.get(idx);
            strings.addLast(strings.removeFirst());
        }
    }

    public int changeDirection(int direction) {
        if(direction == -1) return 1;
        return -1;
    }

    public static void main(String[] args) throws Exception {
        new Main().solution();
    }
}

 

후기