๋ฌธ์
ํด๋น ํฌ์คํ ์ ๋ฐฑ์ค์ ๋ฐฑ์ค ๋ฒ ๋ฌธ์ ๋งํฌ ์ ์ ๊ทผ๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ค๋ช ํ ๊ธ ์ ๋๋ค.
์ ๋ต ์์ค ์ฝ๋๋ฅผ ํ์ธํ์๋ ค๋ฉด solve url ์์ ํ์ธ ๊ฐ๋ฅํฉ๋๋ค.
๋ฌธ์
์์ ์ ๋ ฅ & ์ถ๋ ฅ
ํด๊ฒฐ๋ฒ
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ๊ทผํด์ผ ํ๋์ง์ ์ด๋ค ํธ๋ฆญ์ ํผ์ ํ ํ ์ง๋ฅผ ์๊ฐํด๋ณด๋ ์ค๋ต ํ๋ณด๋ฅผ ๋๋ ์๊ฐํด๋ณด์.
์ ๊ทผ๋ฒ
์ฐ์ ํด๋น ๋ฌธ์ ๋ ์คํ์ ์ด์ฉํด์ ํด๊ฒฐํ ์ ์๋ค.
ABAB๋ผ๋ ๋ฌธ์๋ฅผ ๊ตฌ๋ถํ๋ ค๋ฉด A์ B๊ฐ ์๋ก ๊ฐ๊ณ , AA์ BB๊ฐ ์๋ก ๊ฐ๋ค.
ํ์ง๋ง A์ A๋ฅผ ์์นํ์ผ๋ก ์ ์ ๋ง๋ค๊ณ B์ B๋ฅผ ์์นํ์ผ๋ก ์ ์ ๋ง๋ค๋ฉด ์๋ก ๊ฒน์น๋ ๋ถ๋ถ์ด ์กด์ฌํ๋ฏ๋ก ์ค๋ต์ด๋ค.
ํ์ง๋ง AABB๋ฅผ ์๊ฐํด๋ณด์.
A์ A๋ฅผ ์์นํ์ผ๋ก ์ ์ ๋ง๋ค๊ณ B์ B๋ฅผ ์์นํ์ผ๋ก ์ ์ ๋ง๋ค๋ฉด ์๋ก ๊ฒน์น๋ ๋ถ๋ถ์ด ์์ผ๋ฏ๋ก ์ ๋ต์ด ๋๋ค.
์ด๋ฐ ํด๊ฒฐ๋ฒ์ ์คํ๊ณผ ์ฐ๊ด์ง์ด ์๊ฐํด๋ณด์
์คํ์ ์ฒซ ๋ฒ์งธ ์ธ๋ฑ์ค๋ฅผ push ํ๊ณ ๊ทธ ๋ค์ ์ธ๋ฑ์ค๋ฅผ ๋จ์ ์คํ์ ์์์ ๋น๊ตํด์ ๊ฐ์ผ๋ฉด pop๋ฅผ ํ๋ ์์ผ๋ก ๋ฌธ์์ด์ ๋ชจ๋ ๋ฌธ์๋ฅผ ๊ฒ์ฌํ๋ค.
์ค๋ต ํ๋ณด
- ๋ฌธ์์ด ๊ฒ์ฆ์ด ๋๋ฌ๋๋ฐ, stack์ด ๋น์ด์์ง ์์ ๊ฒฝ์ฐ
ํด๋น ๋ฌธ์ ์ ์ค๋ต ํ๋ณด๋ ํ๋๋ค.
๊ดํธ ๋ฌธ์ ์ฒ๋ผ ๋ฌธ์์ด๋ค์ ๊ดํธ๋ผ๊ณ ์๊ฐํ๋ฉด ์ฝ๋ค.
๊ดํธ ๋ฌธ์ ์ ์ ๊ทผ ๋ฐฉ๋ฒ๊ณผ ๋ก์ง์ด ๋น์ทํ๋ค.
์ ๋ต ์ฝ๋
import java.util.Scanner;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
int answer = 0;
Scanner input = new Scanner(System.in);
int n = input.nextInt();
String[] words = new String[n];
for(int i = 0; i < n; i++) {
words[i] = input.next();
}
for(String word : words) {
Stack<Character> stack = new Stack<>();
check(stack, word);
if(stack.isEmpty()) answer++;
}
System.out.println(answer);
}
// stack๊ณผ ๋น๊ตํ๋ ๋ฉ์๋
private static void check(Stack<Character> stack, String word) {
stack.push(word.charAt(0)); // ์ฒซ ๋ฒ์งธ ๋ฌธ์๋ ๋ฐ๋ก stack์ ์ถ๊ฐ์ํจ๋ค.
/* 2๋ฒ์งธ ๋ฌธ์๋ถํฐ ์คํ์ด ๋น์ด์์ง ์๋ ์ ์์ ๋ฐ๋ณต์ ๋๋ฉฐ pop๊ณผ push๋ฅผ ๋ฐ๋ณต*/
for(int i = 1; i < word.length(); i++) {
if(!stack.isEmpty() && stack.peek() == word.charAt(i)){
stack.pop();
continue;
}
stack.push(word.charAt(i));
}
}
}
๋๊ธ