[BOJ/JAVA] 백준 5430번 : AC

5430번: AC

 

 

 

 

---

 

 

 

 

• 풀이

 

명령(R,D)와 숫자 배열이 있다.

R : front와 rear의 index가 뒤바뀜. front가 rear가되고 rear가 front가 됩니다.

D : 젤 앞인 front의 값을 remove시켜줍니다.

 

==>> dequeue에 최적화된 문제라고 생각했습니다. 이유는 dequeue의 경우 앞과 뒤 둘다 넣고 뺄 수 있기 때문입니다.

 

 

풀이 방식은 다음과 같습니다.

'D'의 명령이 있을 시 boolean변수를 통해 'R'의 명령이 들어올 시 앞을 빼야하는지 뒤를 빼야하는지 체크해줍니다.

'R'의 명령이 있을 시 체크한 boolean 변수를 통해 앞 or 뒤를 빼줍니다.

 

명령이 다 끝날시엔 체크한 boolean변수를 통해 앞에서부터 빼야하는지 뒤부터 빼야하는지 체크해 준 뒤 올바르게 빼주면서 출력합니다.

 

 

 

• 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.*;

public class Main {
	static StringBuilder sb;
	
	public static void main(String[] args) throws Exception {
		SetData();
		System.out.println(sb);
	}
	
	// 데이터
	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);

		sb = new StringBuilder();
		int testcase = in.nextInt();
		
		while(testcase-- > 0) {
            char[] c = in.nextLine().toCharArray();
            int n = in.nextInt();

            String arrStr = in.nextLine();
            Deque<Integer> deque = new LinkedList<>();
            for (String s : arrStr.substring(1, arrStr.length() - 1).split(","))
                if (!s.equals(""))
                    deque.add(Integer.parseInt(s));

            sb.append(AC(deque, c)).append("\n");
		}
	}
	
    static String AC(Deque<Integer> deque, char[] c) {
        boolean reverse = false;

        for (char command : c) {
            if (command == 'R')
                reverse = !reverse;
            else {
                if (deque.size() == 0)
                    return "error";

                if (reverse)
                    deque.removeLast();
                else
                    deque.removeFirst();
            }
        }

        StringBuilder sb = new StringBuilder("[");
        while (!deque.isEmpty()) {
            sb.append(reverse ? deque.removeLast() : deque.removeFirst());
            if (deque.size() != 0)
                sb.append(',');
        }
        sb.append(']');

        return sb.toString();
    }
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}