๐๋ฌธ์ ํ์ํ๊ธฐ
- ์ ์ฌํ๋ฌธ : ๊ทธ ์์ฒด๋ ํ๋ฌธ์ด ์๋์ง๋ง ํ ๋ฌธ์๋ฅผ ์ญ์ ํ์ฌ ํ๋ฌธ์ผ๋ก ๋ง๋ค ์ ์๋ ๋ฌธ์์ด
- ์ ์๋ ๋ฌธ์์ด์ด ๊ทธ ์์ฒด๋ก ํ๋ฌธ์ธ์ง, ์ ์ฌํ๋ฌธ์ธ์ง, ๋ ๋ค ์๋ ์ผ๋ฐ ๋ฌธ์์ด์ธ์ง ํ๋จํ๋ ํ๋ก๊ทธ๋จ ์์ฑํ๊ธฐ
์ ๋ ฅ
- ๋ฌธ์์ด์ ๊ฐ์ T (1 ≤ T ≤ 30)
- T๊ฐ์ ์ค์ ๊ฑธ์ณ ํ ์ค์ ํ๋์ ๋ฌธ์์ด (3 ≤ ๋ฌธ์์ด ๊ธธ์ด ≤ 100,000, ์๋ฌธ ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ง)
์ถ๋ ฅ
- ๊ฐ ๋ฌธ์์ด์ด ํ๋ฌธ์ด๋ฉด 0, ์ ์ฌ ํ๋ฌธ์ด๋ฉด 1, ๋ชจ๋ ์๋๋ฉด 2๋ฅผ ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅ
ํ์ด ๋ฐฉ๋ฒ ์๊ฐํด๋ณด๊ธฐ
ํฌํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํด์ ๋ ๊ฐ์ ํฌ์ธํฐ๊ฐ ์ฒซ ๊ธ์์ ๋ง์ง๋ง ๊ธ์๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํ๊ณ , ๊ฐ ํฌ์ธํฐ๋ฅผ ํ์นธ์ฉ ์ด๋์ํค๋ฉด์ ํ์ฌ ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ธ์๊ฐ ๊ฐ์์ง ํ์ธํ๋ค. ๋ ๊ฐ์ ํฌ์ธํฐ๊ฐ ๋ง๋ ๋๊น์ง ์๋ก ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ธ์๊ฐ ๊ฐ๋ค๋ฉด ํ๋ฌธ์ผ๋ก ํ๋จํ ์ ์๋ค. ๋ง์ฝ ๋ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ธ์๊ฐ ๋ค๋ฅด๋ค๋ฉด, ๋ ์ค ํ๋์ ๋ฌธ์๋ฅผ ์ ๊ฑฐํ๊ณ ํ๋ฌธ ์ฌ๋ถ๋ฅผ ํ๋ณํด์ ์ ์ฌํ๋ฌธ์ ํ๋จํด๋ผ ์ ์๋ค.
์ฃผ์ด์ง ๋ฌธ์์ด์ ๊ฐ์๋งํผ ๊ฐ ๋ฌธ์์ด์ ๋ํด ํ๋ฌธ ์ฌ๋ถ๋ฅผ ํ๋ณํด์ผ ํ๋ฏ๋ก O(30) * O(100,000) = O(3,000,000)์ผ๋ก ์๊ฐ ๋ด์ ํ์ด๊ฐ ๊ฐ๋ฅํ๋ค.
๐์ฝ๋ ์ค๊ณํ๊ธฐ
- ๋ฌธ์์ด์ด ์ฃผ์ด์ง๋ฉด ํ๋ฌธ์ ํ๋ณํ ํจ์ is_palindrome(str, p1, p2, is_pseudo)์ ์ ์ํ๋ค.
- p1์ด p2๋ณด๋ค ์์ ๋ ๋์ ์๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค.
- str[p1]๊ณผ str[p2]๋ฅผ ๋น๊ตํ์ฌ ๊ฐ๋ค๋ฉด p1์ 1์ ๋ํ๊ณ , p2์ 1์ ๋บ๋ค.
- ๋ง์ฝ str[p1], str[p2]๊ฐ ๋ค๋ฅด๋ค๋ฉด, is_pseudo๊ฐ True์ธ ๊ฒฝ์ฐ 2์ ๋ฐํํ๊ณ , is_pseudo๊ฐ False๋ผ๋ฉด is_palindrome(str, p1+1, p2, True), is_palindrome(str, p1, p2-1, True)๋ฅผ ํธ์ถํด ๋ ์ค ํ๋๊ฐ 0์ด๋ผ๋ฉด 1์ ๋ ๋ค 2๋ผ๋ฉด 2๋ฅผ ๋ฐํํ๋ค.
- p1์ด p2๋ณด๋ค ๊ฐ๊ฑฐ๋ ์ปค์ง ๊ฒฝ์ฐ, 0์ ๋ฐํํ๋ค.
- ๋ฌธ์์ด์ ๊ฐ์๋ฅผ ์ ์ฅํ ๋ณ์ T๋ฅผ ์์ฑํ๊ณ , ๋ฌธ์์ด ๊ฐ์๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค.
- T๋งํผ ๋ฐ๋ณตํ๋ฉด์, ๋ฌธ์์ด str์ ์ ๋ ฅ๋ฐ๊ณ is_palindrome(str, 0, len(str)-1, False)์ ํธ์ถํด์ ๋ฌธ์์ด์ ์ข ๋ฅ๋ฅผ ํ๋ณํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ๋ฐ๋๋ค.
- 3์์ ๋ฐํ๋ ๊ฒฐ๊ณผ๋ฅผ ํ ์ค์ฉ ์ถ๋ ฅํ๋ค.
๐ ์ ๋ต ์ฝ๋
Python
import sys
input = sys.stdin.readline
def is_palindrome(str, p1, p2, is_pseudo):
while p1 < p2:
if str[p1] == str[p2]:
p1 += 1
p2 -= 1
else:
if is_pseudo: return 2
return 2 if is_palindrome(str, p1+1, p2, True) and is_palindrome(str, p1, p2-1, True) else 1
return 0
for _ in range(int(input())):
str = input().strip()
print(is_palindrome(str, 0, len(str)-1, False))
Java
import java.io.*;
public class Main {
public static int is_palindrome(String str, int p1, int p2, boolean is_pseudo) {
while (p1 < p2) {
if (str.charAt(p1) == str.charAt(p2)) {
p1++;
p2--;
} else {
if (is_pseudo) return 2;
if (is_palindrome(str, p1, p2-1, true) == 0 || is_palindrome(str, p1+1, p2, true) == 0) return 1;
return 2;
}
}
return 0;
}
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(br.readLine());
for (int i = 0; i < T; i++) {
String str = br.readLine();
System.out.println(is_palindrome(str, 0, str.length()-1, false));
}
}
}
์๊ฐ ๋ณต์ก๋
๊ฐ ๋ฌธ์๋ง๋ค ํ ๋ฒ์ฉ is_palindrome์ ํตํด ํ๋ฌธ ๊ฒ์ฌ๋ฅผ ํ๋ค. ํ๋ฌธ ๊ฒ์ฌ์ ๊ฒฝ์ฐ, ๋ฌธ์์ด์ ์ ๋์์ ์ค์์ผ๋ก ์ด๋ํ๋ฉด์ ๋น๊ตํ๋ ๋ฐ O(n)์ ์๊ฐ๋ณต์ก๋๊ฐ ์์๋๋ค. ๋ฌธ์๊ฐ ๋ค๋ฅผ ๊ฒฝ์ฐ ์ต๋ 2๊ฐ์ ์ฌ๊ท ํธ์ถ์ ์ํํ์ง๋ง, is_pseudo ์กฐ๊ฑด๋ฌธ์ ์ํด ์ต๋ ํ ๋ฒ ๊น์ด์ ์ฌ๊ท ํธ์ถ์ด ์ผ์ด๋๋ฏ๋ก, ์ต์ ์ ๊ฒฝ์ฐ์๋ O(n)์ผ๋ก ๋์ํ๋ค.
๊ณต๊ฐ ๋ณต์ก๋
์ฌ๊ท ํธ์ถ์ ๋ฐ๋ฅธ ์คํ ์ฌ์ฉ์ด ์ฃผ์ ๊ณต๊ฐ ์ฌ์ฉ์ธ๋ฐ, ์ฌ๊ท ๊น์ด๊ฐ ์ต๋ 2(์ต์ด ํธ์ถ + ์ต๋ 1๋ฒ์ ์ฌ๊ท ํธ์ถ)์ด๊ณ , ๊ฐ ์ฌ๊ท ํธ์ถ์์๋ ์์ ๊ฐ์ ๋ณ์๋ง ์ฌ์ฉํ๋ฏ๋ก ๊ณต๊ฐ ๋ณต์ก๋๋ O(1)์ด๋ค.