[BOJ][๐ก5][๋ฐฑ์ค#17609] ํ๋ฌธ
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
ํ๋ฌธ(ๅๆ) ๋๋ ํฐ๋ฆฐ๋๋กฌ(palindrome)์ ์ ๋ค ๋ฐฉํฅ์ผ๋ก ๋ณผ ๋ ๊ฐ์ ์์์ ๋ฌธ์๋ก ๊ตฌ์ฑ๋ ๋ฌธ์์ด์ ๋งํ๋ค. ์๋ฅผ ๋ค์ด โabbaโ โkayakโ, โreviverโ, โmadamโ์ ๋ชจ๋ ํ๋ฌธ์ด๋ค. ๋ง์ผ ๊ทธ ์์ฒด๋ ํ๋ฌธ์ด ์๋์ง๋ง ํ ๋ฌธ์๋ฅผ ์ญ์ ํ์ฌ ํ๋ฌธ์ผ๋ก ๋ง๋ค ์ ์๋ ๋ฌธ์์ด์ด๋ผ๋ฉด ์ฐ๋ฆฌ๋ ์ด๋ฐ ๋ฌธ์์ด์ โ์ ์ฌํ๋ฌธโ(pseudo palindrome)์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ์๋ฅผ ๋ค์ด โsummuusโ๋ 5๋ฒ์งธ๋ ํน์ 6๋ฒ์งธ ๋ฌธ์ โuโ๋ฅผ ์ ๊ฑฐํ์ฌ โsummusโ์ธ ํ๋ฌธ์ด ๋๋ฏ๋ก ์ ์ฌํ๋ฌธ์ด๋ค. ์ฌ๋ฌ๋ถ์ ์ ์๋ ๋ฌธ์์ด์ ๋ถ์ํ์ฌ ๊ทธ๊ฒ์ด ๊ทธ ์์ฒด๋ก ํ๋ฌธ์ธ์ง, ๋๋ ํ ๋ฌธ์๋ฅผ ์ญ์ ํ๋ฉด ํ๋ฌธ์ด ๋๋ โ์ ์ฌํ๋ฌธโ์ธ์ง, ์๋๋ฉด ํ๋ฌธ์ด๋ ์ ์ฌํ๋ฌธ๋ ์๋ ์ผ๋ฐ ๋ฌธ์์ด์ธ์ง๋ฅผ ํ๋จํด์ผ ํ๋ค. ๋ง์ผ ๋ฌธ์์ด ๊ทธ ์์ฒด๋ก ํ๋ฌธ์ด๋ฉด 0, ์ ์ฌํ๋ฌธ์ด๋ฉด 1, ๊ทธ ์ธ๋ 2๋ฅผ ์ถ๋ ฅํด์ผ ํ๋ค.ย
์ ๋ ฅ
์ ๋ ฅ์ ์ฒซ ์ค์๋ ์ฃผ์ด์ง๋ ๋ฌธ์์ด์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ ์ T(1 โค T โค 30)๊ฐ ์ฃผ์ด์ง๋ค. ๋ค์ ์ค๋ถํฐ T๊ฐ์ ์ค์ ๊ฑธ์ณ ํ ์ค์ ํ๋์ ๋ฌธ์์ด์ด ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค. ์ฃผ์ด์ง๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ 3 ์ด์ 100,000 ์ดํ์ด๊ณ , ์๋ฌธ ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์๋ค.
์ถ๋ ฅ
๊ฐ ๋ฌธ์์ด์ด ํ๋ฌธ์ธ์ง, ์ ์ฌ ํ๋ฌธ์ธ์ง, ๋ ๋ชจ๋ ํด๋น๋์ง ์๋์ง๋ฅผ ํ๋จํ์ฌ ํ๋ฌธ์ด๋ฉด 0, ์ ์ฌ ํ๋ฌธ์ด๋ฉด 1, ๋ ๋ชจ๋ ์๋๋ฉด 2๋ฅผ ์์๋๋ก ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค.
์์
์ ๋ ฅ
7
abba
summuus
xabba
xabbay
comcom
comwwmoc
comwwtmoc
์ถ๋ ฅ
0
1
1
2
2
0
1
My Sol
import sys
input = sys.stdin.readline
from collections import deque
from copy import deepcopy
def check():
txt = deque(input().rstrip())
tl = len(txt)
txt, tl = check2(txt, tl)
if tl < 2: return 0
txt_a = deepcopy(txt)
txt_a.pop()
txt1, tl1 = check2(txt_a, tl-1)
if tl1 < 2: return 1
txt_b = deepcopy(txt)
txt_b.popleft()
txt2, tl2 = check2(txt_b, tl-1)
return 2 if tl2 > 1 else 1
def check2(txt, tl):
while tl >= 2:
if txt[0] == txt[-1]:
txt.pop()
txt.popleft()
tl -= 2
continue
break
return txt, tl
T = int(input().rstrip())
for _ in range(T):
print(check())
deque๋ฅผ ์ด์ฉํด ์ ๋์ ์ํ๋ฒณ์ด ๊ฐ๋ค๋ฉด ํ๋์ฉ ๋นผ์ฃผ๋ฉฐ ํ์ธํ๋ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค. ํ ๋ฌธ์ ๋ฅผ ์ ๊ฑฐํ๋ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ง์ฝ ์์ชฝ์ ์ ๊ฑฐํ๋ค๊ฐ ์ผ์นํ์ง ์๋ ๊ฒฝ์ฐ๋ฅผ ๋ง๋๋ค๋ฉด ๊ทธ ๋๊น์ง์ deque์ ๊ธธ์ด๋ฅผ ๋ฐํํ๋ ํจ์ check2๋ฅผ ๋ง๋ ๋ค. ๊ทธ๋ฆฌ๊ณ ์ต์ด ์ ๋ ฅ์ ๋ํ deque๋ฅผ check2์ ๋ฃ์ผ๋ฉด ํ ๋ฒ์ ํ๋ฌธ ์ฒดํฌ๋ฅผ ํ ์ ์๋ค. ์ฌ๊ธฐ์ ๊ธธ์ด๊ฐ 1 ์ด์์ด๋ผ๋ฉด ๊ทธ ์์ฒด๋ก ํ๋ฌธ์ด ์๋ ์ํฉ์ด๋ค.
๋ง์ฝ ๊ทธ๋ ๋ค๋ฉด ํด๋น deque์ ๋ํด ์์ ์ํ๋ฒณ์ ๋บ ๊ฒฝ์ฐ์ ๋ค์ ์ํ๋ฒณ์ ๋บ ๊ฒฝ์ฐ์ ๋ํด check2๋ฅผ ๋ค์ ๋๋ ค ํ์ธํ๋ฉด ๋๊ฒ ๋๋ฐ, ํ ๊ฒฝ์ฐ๋ผ๋ ํ๋ฌธ์ธ ๊ฒฝ์ฐ์๋ 1, ์๋๋ผ๋ฉด 2๋ฅผ ๋ฐํํด ์ถ๋ ฅํ๋ค.
์ ์ ์๋ ์ด์ ๋ก ๊ณ์ ํ๋ ค์ ํ๋ค๊ฒ ํ์ด๋๋๋ฐ, ์๊ณ ๋ณด๋ ํ ๋ฒ ํ๋ฌธ ์ฒดํฌ๋ฅผ ๋ง์น txt deque๋ฅผ ๋ ๊ฐ์ง ๊ฒฝ์ฐ๋ก check2๋ฅผ ๋๋ฆฌ๋ ๊ฒฝ์ฐ txt์ ์ ๋ค ๋ฌธ์๋ฅผ ๋นผ๋ด๊ณ append ํด์ฃผ์๋๋ฐ, ์๊ณ ๋ณด๋ ์์๋ณต์ฌ๊ฐ ๋์ด์ ๋ ๋ฒ์งธ ๊ฒฝ์ฐ์ ์ฒดํฌ๋ฅผ ํ๋ ๊ฒฝ์ฐ์ ์ด์ ์ฒซ ๋ฒ์งธ ๊ฒฝ์ฐ์ ์ฒดํฌ๊น์ง ๋ง์น deque๊ฐ ๋ค์ด๊ฐ๋ ๊ฒ์ด์๋ค. ์ด๋ฅผ ํ์ ํ๊ณ deepcopy๋ก ๋ณ๊ฒฝํ์ ํด๊ฒฐํ ์ ์์๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
from sys import stdin
input = stdin.readline
def is_palindrome(string):
p1 = 0
p2 = len(string) - 1
while p1 < p2:
if string[p1] == string[p2]:
p1 += 1
p2 -= 1
else:
tmp1 = string[:p1] + string[p1 + 1:]
tmp2 = string[:p2] + string[p2 + 1:]
if tmp1[:] == tmp1[::-1] or tmp2[:] == tmp2[::-1]:
return 1
else:
return 2
return 0
T = int(input())
for _ in range(T):
string = input().strip()
print(is_palindrome(string))
์ฐ์ฐ์๊ฐ์ด ์งง์ ํ์ด๋ฅผ ๋ฐ๊ฒฌํด์ ๋ถ์ํด๋ณด๋ ค ํ๋ค. ์ด ๋ถ์ index๋ฅผ ์ด์ฉํ slicing์ผ๋ก ๋ฌธ์ ๋ฅผ ํ์ด๋ด์ จ๋ค. ์๊ฐ๊ณผ ๊ณต๊ฐ ๋ณต์ก๋ ๋๋ฌธ์ ๋๋๋ก ์ฌ๋ผ์ด์ฑ์ ์ง์ํ๋ ํธ์ธ๋ฐ, ์ด์ฐจํผ ๋ด๊ฐ ํ ๋ฐฉ์์ด๋ ์ด ๋ถ ๋ฐฉ์์ด๋ ๋ฐฐ์ด์ ๋ค์ ์ ์ฅํ๋ ๋ฐฉ์์ด๋ผ ํฌ๊ฒ ๋ค๋ฆ์ด ์๋ค๊ณ ๋๊ผ๋ค.
์ฒ์์ผ๋ก ์ผ์นํ์ง ์๋ ์๊ฐ๊น์ง ์์ชฝ์ ์ธ๋ฑ์ค๋ฅผ ์กฐ์ ํ๋ฉฐ ์ขํ์ค๋ค๊ฐ ์ผ์นํ์ง ์๋ ์๊ฐ์ ์ธ๋ฑ์ค์ ์กฐ์ ๊ณผ ์ฌ๋ผ์ด์ฑ์ผ๋ก ๋ฐฐ์ด์ ๋น๊ตํ๊ณ , ์ด์ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ์ฌ ์ถ๋ ฅํ๋ค. ๋๋ํ ๋ฐฉ์์ด๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ