
์ ์์ด๋ ์ฃผ๋ง์ ํ ์ผ์ด ์์ด์ ์๋ก์ด ์ธ์ด AC๋ฅผ ๋ง๋ค์๋ค. AC๋ ์ ์ ๋ฐฐ์ด์ ์ฐ์ฐ์ ํ๊ธฐ ์ํด ๋ง๋ ์ธ์ด์ด๋ค. ์ด ์ธ์ด์๋ ๋ ๊ฐ์ง ํจ์ R(๋ค์ง๊ธฐ)๊ณผ D(๋ฒ๋ฆฌ๊ธฐ)๊ฐ ์๋ค.
ํจ์ R์ ๋ฐฐ์ด์ ์๋ ์์ ์์๋ฅผ ๋ค์ง๋ ํจ์์ด๊ณ , D๋ ์ฒซ ๋ฒ์งธ ์๋ฅผ ๋ฒ๋ฆฌ๋ ํจ์์ด๋ค. ๋ฐฐ์ด์ด ๋น์ด์๋๋ฐ D๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
ํจ์๋ ์กฐํฉํด์ ํ ๋ฒ์ ์ฌ์ฉํ ์ ์๋ค. ์๋ฅผ ๋ค์ด, "AB"๋ A๋ฅผ ์ํํ ๋ค์์ ๋ฐ๋ก ์ด์ด์ B๋ฅผ ์ํํ๋ ํจ์์ด๋ค. ์๋ฅผ ๋ค์ด, "RDD"๋ ๋ฐฐ์ด์ ๋ค์ง์ ๋ค์ ์ฒ์ ๋ ์๋ฅผ ๋ฒ๋ฆฌ๋ ํจ์์ด๋ค.
๋ฐฐ์ด์ ์ด๊ธฐ๊ฐ๊ณผ ์ํํ ํจ์๊ฐ ์ฃผ์ด์ก์ ๋, ์ต์ข ๊ฒฐ๊ณผ๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ฒซ์งธ ์ค์ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. T๋ ์ต๋ 100์ด๋ค.
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ์ฒซ์งธ ์ค์๋ ์ํํ ํจ์ p๊ฐ ์ฃผ์ด์ง๋ค. p์ ๊ธธ์ด๋ 1๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 100,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค.
๋ค์ ์ค์๋ ๋ฐฐ์ด์ ๋ค์ด์๋ ์์ ๊ฐ์ n์ด ์ฃผ์ด์ง๋ค. (0 โค n โค 100,000)
๋ค์ ์ค์๋ [x1,...,xn]๊ณผ ๊ฐ์ ํํ๋ก ๋ฐฐ์ด์ ๋ค์ด์๋ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. (1 โค xiย โค 100)
์ ์ฒด ํ ์คํธ ์ผ์ด์ค์ ์ฃผ์ด์ง๋ p์ ๊ธธ์ด์ ํฉ๊ณผ n์ ํฉ์ 70๋ง์ ๋์ง ์๋๋ค.
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ๋ํด์, ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ์ ์ ๋ฐฐ์ด์ ํจ์๋ฅผ ์ํํ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ, ์๋ฌ๊ฐ ๋ฐ์ํ ๊ฒฝ์ฐ์๋ error๋ฅผ ์ถ๋ ฅํ๋ค.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Deque;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
while (t-- > 0) {
String p = br.readLine(); // ์ํํ ํจ์
int n = Integer.parseInt(br.readLine()); // ๋ฐฐ์ด์ ๋ค์ด์๋ ์์ ๊ฐ์
String line = br.readLine();
Deque<Integer> deque = new ArrayDeque<>();
if(n != 0) {
String[] strArr = line.substring(1, line.length() - 1).split(",");
for (String val : strArr) {
deque.offer(Integer.parseInt(val));
}
}
boolean isReverse = false; // ๋ฐฐ์ด์ ๋ค์ง์์ง ์ฌ๋ถ
boolean isError = false; // "error"๋ฅผ ์ถ๋ ฅํ ์ง ์ฌ๋ถ
for (int i = 0; i < p.length(); i++) {
if (p.charAt(i) == 'R') {
isReverse = !isReverse;
} else {
// char ๊ฐ์ด 'D'์ธ๋ฐ dequeue ๊ฐ์ด ๋น์ด์์ผ๋ฉด error ์ถ๋ ฅ
if (deque.isEmpty()) {
isError = true;
break;
}
if (isReverse) {
deque.pollLast();
} else {
deque.poll();
}
}
}
if (isError) {
System.out.println("error");
} else {
StringBuilder sb = new StringBuilder();
sb.append("[");
while (!deque.isEmpty()) {
if (isReverse) {
sb.append(deque.pollLast()).append(",");
} else {
sb.append(deque.poll()).append(",");
}
}
if(sb.length() > 1) {
sb.setLength(sb.length() - 1);
}
sb.append("]");
System.out.println(sb.toString());
}
}
}
}
ํด๋น ๋ฌธ์ ๋ ๋ค์ง์ด์ ์ถ๋ ฅํ ์ง ์ฌ๋ถ์ ๋ฐ๋ผ ๋ฐฐ์ด์ ์ ํน์ ๋ค์์ ๊ฐ์ ์ญ์ ํด์ค์ผ ํ๊ธฐ ๋๋ฌธ์ ์์ชฝ์ผ๋ก ์ถ๋ ฅ์ด ๊ฐ๋ฅํ Dequeue๋ฅผ ํ์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์ต๋๋ค.
์ํํ ํจ์, ๋ฐฐ์ด์ ๋ค์ด์๋ ์, ๋ฐฐ์ด ๊ฐ์ ํ์ธํ์ฌ Dequeue์ ๊ฐ์ ๋ด์ต๋๋ค.isReverse, error๋ฅผ ์ถ๋ ฅ ์ฌ๋ถ isError๋ฅผ ์ ์ธํ์ฌ ํจ์ String์ ์ํํ๋ฉฐ ์ฒดํฌํฉ๋๋ค.error ํน์ ๋ฐฐ์ด ๊ฒฐ๊ณผ๊ฐ์ ์ถ๋ ฅํด์ค๋๋ค