Tags
- PGM
- SpringBoot
- sort
- BOJ
- ๋ฐฑํธ๋ํน
- ์๋ฃ๊ตฌ์กฐ
- Python
- ๊ตฌํ
- ์ ๋ ฌ
- ์ ์๋ก
- greedy
- ๊ทธ๋ํ ํ์
- CodingTest
- queue
- dfs
- DP
- ๊น์ด ์ฐ์ ํ์
- ๊ทธ๋ํ ์ด๋ก
- Dynamic Programming
- ๊ต์ฌ
- ๋ฌธ์์ด
- ์ํ
- Brute Force Algorithm
- Study
- BFS
- Java
- ๋๋น ์ฐ์ ํ์
- LV2
- ์๋ฎฌ๋ ์ด์
- stack
Archives
๊ธฐ๋ก๋ฐฉ
BOJ_9935 : ๋ฌธ์์ด ํญ๋ฐ ๋ณธ๋ฌธ
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
- ๊ธฐ๋ณธ ๋ฌธ์์ด๊ณผ ํญ๋ฐ ๋ฌธ์์ด์ด ์ ๋ ฅ๋๋ค.
- ๊ธฐ๋ณธ ๋ฌธ์์ด์์ ํญ๋ฐ ๋ฌธ์์ด ๋ถ๋ถ์ด ํญ๋ฐํ๋ฉฐ ์ง์์ง๊ณ , ๋จ์ ๋ฌธ์์ด์ ๋ค์ ์ด์ด ๋ถ๋๋ค.
- ๋ ํญ๋ฐํ ๋ฌธ์์ด์ด ๋จ์ง ์์์ ์ํ์ ๋ฌธ์์ด์ ์ถ๋ ฅํ๋ค.
- ๋จ์ ๋ฌธ์๊ฐ ์์ผ๋ฉด "FRULA"๋ฅผ ์ถ๋ ฅํ๋ค.
๐ธ ๋ฌธ์ ํ์ด ๐ธ
- ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ 100๋ง์ด๊ธฐ ๋๋ฌธ์ O(n^2) ๋ฏธ๋ง์ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํด์ผ ํ๋ค.
- ๋ฐ๋ณต๋ฌธ ํ ๋ฒ์ ๊ณ์ฐํ ์ ์๋๋ก ํ๋ค.
- ์๋ก์ด ๋ฌธ์์ด์ด ์๊ธฐ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์์ผ๋ฏ๋ก, ๋ฌธ์ ๋ฐฐ์ด์ ์คํ ๊ตฌ์กฐ๋ก ํญ๋ฐ ๋ฌธ์์ด์ธ์ง ํ์ธํ๋ค.
- ํญ๋ฐ ๋ฌธ์์ด์ ๋ง์ง๋ง ๋ฌธ์์ด๋ฉด, ์คํ์์ ํญ๋ฐ ๋ฌธ์์ด ํฌ๊ธฐ๋งํผ ๊บผ๋ด์ ํ์ธํ๋ค.
- ํญ๋ฐํ๋ฉด ์ง์ฐ๊ณ , ํญ๋ฐํ์ง ์์ผ๋ฉด ๋ค์ ์คํ์ ๋ฃ์ด์ค๋ค.
- ์คํ์ ๋จ์ ๋ฌธ์์ด์ ์ถ๋ ฅํ๋ค.
๐ธ ์ฝ๋ ๐ธ
import java.io.*;
import java.util.Stack;
public class Main {
private static Stack<Character> stack;
private static char[] boom;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
char[] chars = br.readLine().toCharArray();
boom = br.readLine().toCharArray();
int last = boom[boom.length - 1];
stack = new Stack<>();
for (char c : chars) { // ์
๋ ฅ๋ ๋ฌธ์์ด ๊ฒ์ฌ
if (stack.size() >= boom.length - 1 && c == last) { // ํญ๋ฐ ๋ฌธ์์ด์ ๋ง์ง๋ง ๋ฌธ์์ ๊ฐ์ผ๋ฉด ํญ๋ฐ๋๋์ง ํ์ธ
if (!boomCheck()) { // ์ํฐ์ก์ผ๋ฉด ์ง๊ธ ๋ฌธ์ ์คํ ๋ฃ๊ธฐ
stack.push(c);
}
} else {
stack.push(c);
}
}
if (stack.size() == 0) {
bw.write("FRULA");
} else {
StringBuilder sb = new StringBuilder();
while (!stack.isEmpty()) sb.append(stack.pop());
bw.write(sb.reverse().toString());
}
bw.flush();
}
private static boolean boomCheck() { // ํญ๋ฐ ๊ฒ์ฌ : ํฐ์ง๋ฉด ์ญ์
char c;
for (int i = boom.length - 2; i >= 0; i--) {
if (stack.isEmpty()) {
for (int j = i + 1; j < boom.length - 1; j++) {
stack.push(boom[j]);
}
return false;
} else if ((c = stack.pop()) != boom[i]) { // ํญ๋ฐ ๋ฌธ์์ด ์๋ : ๋ณต๊ตฌ
stack.push(c);
for (int j = i + 1; j < boom.length - 1; j++) {
stack.push(boom[j]);
}
return false;
}
}
return true;
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- ๊ธฐ๋ณธ ๋ฌธ์์ ํญ๋ฐ ๋ฌธ์์ด์ ์ ๋ ฅ๋ฐ์ char๋ฐฐ์ด๋ก ์ ์ฅํ๋ค.
- ์
๋ ฅ๋ ๋ฌธ์์ด์ ํ๋์ฉ ๊ฒ์ฌํด ํญ๋ฐ ๋ฌธ์์ด์ ๋ง์ง๋ง ๋ฌธ์๊ฐ ๋์ค๋ฉด boomCheck() ๋ฉ์๋์์ ํญ๋ฐ์ ํ์ธํ๋ค.
- ํญ๋ฐํ๋ฉด ์ง์์ฃผ๊ณ , ํญ๋ฐํ์ง ์์ผ๋ฉด ํด๋น ๋ฌธ์๋ฅผ stack์ ์ถ๊ฐํ๋ค.
- boomCheck() ์์ stack์ ๋ฌธ์๋ฅผ ํ๋์ฉ ๊บผ๋ด ํญ๋ฐ ๋ฌธ์์ด๊ณผ ๋น๊ตํ๋ค.
- ์คํ์ด ๋ชจ๋ ๋น์ด๋ฒ๋ฆฌ๊ฑฐ๋ ์ผ์นํ์ง ์๋ ๊ฒฝ์ฐ๊ฐ ์๊ธฐ๋ฉด, ๋ณต๊ตฌํ๋ค.
- ํญ๋ฐ ๋ฌธ์์ด์ด ์์ฑ๋๋ฉด ๋ณต๊ตฌํ์ง ์๊ณ true๋ฅผ ๋ฐํํ๋ค.
- ์ต์ข stack์ ๋จ์ ๋ฌธ์์ด์ ํ์ธํด ๋ฌธ์์ด์ ์ถ๋ ฅํ๋ค.
๐ธ end ๐ธ
- ๋ฌธ์์ด ์ฒ๋ฆฌ ๋ฌธ์ ์ฌ์ ์ฝ๊ฒ ๋ดค๋ค๊ฐ ๋ง์ด ํ๋ฆฌ๊ฒ ๋์๋ค.
- ์ฒซ ์๋๋ ํญ๋ฐ ํ ๋ฌธ์์ด์ StringBuilder๋ก ๋ชจ์์ ๋ค์ chars๋ฅผ ๊ฐฑ์ ํ๋ ๋ฐฉ์์ธ๋ฐ, ์๋ก์ด ๋ฌธ์์ด์ด ๊ณ์ ์์ฑ๋์ด์ ๊ทธ๋ฐ์ง ๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ๊ฐ ๋ฌ๋ค.
- ๋๋ฒ์งธ๋ ํญ๋ฐ ๋ฌธ์์ด์ด ๋จ์ง ์์ ๋ ๊น์ง ๋ฐ๋ณต๋ฌธ์ ๋ค์ ๋๋๋ฐ, O(n^2)๋ผ์ ์๊ฐ ์ด๊ณผ๊ฐ ๋ฌ๋ค.
- ์ธ๋ฒ์งธ๋ ์คํ ๊ตฌ์กฐ๋ก ๋ณ๊ฒฝํ๋๋ฐ ํญ๋ฐ ๋ฌธ์์ด์ ํฌ๊ธฐ๊ฐ 2์ดํ๊ฑฐ๋, ์คํ์ด ๋น์์ ๊ฒฝ์ฐ ๋ฑ์ ์์ธ์ฒ๋ฆฌ๊ฐ ๋ถ์กฑํด์ ํ๋ ธ๋ค.
- ์ค๋๋ง์ ์คํ ๋ฌธ์ ์ฌ์ ์ ์ ํ๋ ๊ฒ ๊ฐ๋ค.
728x90
'CodingTest > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ_11054 : ๊ฐ์ฅ ๊ธด ๋ฐ์ดํ ๋ ๋ถ๋ถ ์์ด (0) | 2024.03.10 |
---|---|
BOJ_11779 : ์ต์๋น์ฉ ๊ตฌํ๊ธฐ 2 (0) | 2024.03.02 |
BOJ_1033 : ์นตํ ์ผ (0) | 2024.02.29 |
BOJ_1850 : ์ต๋๊ณต์ฝ์ (0) | 2024.02.21 |
BOJ_11689 : GCD(n, k) = 1 (0) | 2024.02.21 |