๐ ๋ฐฑ์ค 1406 - ์๋ํฐ
๐ก ๋์ ํ์ด
์ด์ ์์ํ๋ 2021 ์นด์นด์ค ์ธํด์ญ ์จ๋ผ์ธ ์ฝ๋ฉ ํ
์คํธ์์๋ ๋น์ทํ ๋ฌธ์ ๊ฐ ๋์๋ค. ๋ค๋ง ๊ฑฐ๊ธฐ์๋ ctl + z
๊ธฐ๋ฅ๋ ํฌํจ๋์ด์์ด์ ์กฐ๊ธ ๋ ์ด๋ ค์ ๋๊ฒ ๊ฐ๋ค. ๋์ค์ ํด์ค์ด ๋์ค๋ฉด ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ๊ทผํ๋์ง ์ดํด๋ด์ผ๊ฒ ๋ค.
์ด ๋ฌธ์ ๋ ์ด๋ป๊ฒ ํ์ด์ผ ํ ์ง ์ ๋ง ๋ง์ด ๊ณ ๋ฏผํ๋๋ฐ, ๊ฒฐ๊ณผ์ ์ผ๋ก stack
ํน์ deque
๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๊ฒ ํ ์ ์๋ ๋ฌธ์ ์๋ค. ๊ทธ๋ฆฌ๊ณ ๋ฌธ์ ์์ ์๊ฐ ์ ํ์ด 0.3์ด๋ก ์ฃผ์ด์ ธ์์ด์ O(N^2)์ผ๋ก๋ ํ ์ ์๋ค.
์ฒซ ์๋์์ len(s)
๋งํผ cursor
๋ฅผ ์ ์ธํด์ ํ์์ง๋ง B
๋ช
๋ น์ด์ ์์ธ์ฒ๋ฆฌ๋ฅผ ์ด๋ป๊ฒ ํด์ค์ผํ ์ง ๋ชจ๋ฅด๊ฒ ๋ค. ๊ทธ๋ฆฌ๊ณ cursor
๋ฅผ ์ฌ์ฉํด์ insert
์ remove
๋ฅผ ์ฌ์ฉํ๋๋ฐ ๊ฐ๊ฐ ์๊ฐ๋ณต์ก๋๊ฐ O(N)
์ด๊ณ ์
๋ ฅ์ธ ๋ช
๋ น์ด๋ฅผ ๋ฐ๊ธฐ์ํด ์ฒ์์ ๋ฐ๋ณต๋ฌธ์ ํ๋ฒ ์ ์ธํ๊ธฐ ๋๋ฌธ์ ์ด์ค ๋ฐ๋ณต๋ฌธ์ด ๋๋ ํํ์๋ค.
์ฒ์์ deque
๋ก ํ๊ณ , ๋๋ฒ์งธ๋ stack
์ผ๋ก ํ์๋ค. ๋ ๋ฐฉ์ ๋ชจ๋ ์๊ฐ ๋ณต์ก๋๊ฐ O(N)์ด๊ธฐ ๋๋ฌธ์ ์คํ์๊ฐ์ ๊ฐ๊ฐ 364ms
, 352ms
๋ก ์ฐจ์ด๊ฐ ๋ง์ง ์์๋ค.
- ๋น
deque ํน์ stack
์ ์ ์ธํ๋ค. L
: ์ปค์๋ฅผ ์ผ์ชฝ์ผ๋ก ํ ์นธ ์ฎ๊ธฐ๋ ๋ช ๋ น์ด์ธL
์ด ๋ค์ด์ค๋ฉดL
๋ณด๋ค ์ค๋ฅธ์ชฝ์ ์๋ ๊ฐ๋ค ๋ชจ๋deque_R
๋ก ์ฎ๊ธด๋ค. ์ฎ๊ธธ๋๋append
๊ฐ ์๋appendleft()
๋ก ํด์ฃผ๋๊ฒ์ ์์ง ๋ง์.D
: ๋ฐ๋๋ก ์ปค์๊ฐ ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ ์ฎ๊ธฐ๋ ๋ช ๋ น์ด์ธD
๊ฐ ๋ค์ด์ค๋ฉดD
๋ณด๋ค ์ผ์ชฝ์ ์๋ ๊ฐ๋ค ๋ชจ๋deque_L
๋ก ์ฎ๊ธด๋ค. ์ฎ๊ธธ ๋๋append
๊ฐ ์๋appendleft()
๋ก ํด์ฃผ๋๊ฒ์ ์์ง ๋ง์.B
: ์ญ์ ํ๋ ๊ธฐ๋ฅ์pop
์ผ๋ก ํด๊ฒฐํ๋ค.P
: ์ถ๊ฐํ๋ ๊ธฐ๋ฅ์append
๋ก ํด๊ฒฐํ๋ค.
๋ช
๋ น์ด L
, D
, B
๊ณตํต์ ์ผ๋ก ์ปค์๊ฐ ๋ฌธ์ฅ์ ๋งจ ์ / ๋งจ ๋ค๋ฉด ๋ฌด์ํ๋ผ๋ ์กฐ๊ฑด์ด ์๋๋ฐ, ์ด๋ deque
์ ๊ธธ์ด๋ณด๋ค ์์ผ๋ฉด ๋ฌด์ํ๋ ์กฐ๊ฑด์ ๋ฃ์ด์ฃผ๋ฉด ๋๋ค.deque
์ ์ถ๋ ฅ์ ๋ฆฌ์คํธ๋ฅผ ์๋ก ๋ํด์ฃผ๊ณ join
์ ํด์ฃผ๋ฉด ๋๋๋ฐ, stack
๊ฐ์ ๊ฒฝ์ฐ๋ ๊ฑฐ๊พธ๋ก ๋ค์ง์ด์ค์ผ(reversed) ์ ์์ ์ธ ์ถ๋ ฅ์ด ๋์จ๋ค.
# deque
import sys
from collections import deque
input = sys.stdin.readline
deque_L, deque_R = list(input().strip()), deque([])
m = int(input())
for i in range(m):
command = input().split()
if 'L' in command:
if not deque_L:
continue
deque_R.appendleft(deque_L.pop())
elif 'D' in command:
if not deque_R:
continue
deque_L.append(deque_R.popleft())
elif 'B' in command:
if not deque_L:
continue
deque_L.pop()
else:
deque_L.append(command[1])
print(''.join(deque_L + list(deque_R)))
# stack
import sys
input = sys.stdin.readline
stack_L, stack_R = list(input().strip()), []
m = int(input())
for i in range(m):
command = input().split()
if 'L' in command:
if not stack_L:
continue
stack_R.append(stack_L.pop())
elif 'D' in command:
if not stack_R:
continue
stack_L.append(stack_R.pop())
elif 'B' in command:
if not stack_L:
continue
stack_L.pop()
else:
stack_L.append(command[1])
print(''.join(stack_L + list(reversed(stack_R))))
'Algorithm > ๋ฐฑ์ค(BOJ)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ ํ์ด์ฌ(python) ] ๋ฐฑ์ค 2948 - 2009๋ (0) | 2021.05.11 |
---|---|
[ ํ์ด์ฌ(python) ] ๋ฐฑ์ค 2167 - 2์ฐจ์ ๋ฐฐ์ด์ ํฉ (0) | 2021.05.10 |
[ ํ์ด์ฌ(python) ] ๋ฐฑ์ค 2693 - N๋ฒ์งธ ํฐ ์ (0) | 2021.05.07 |
[ ํ์ด์ฌ(python) ] ๋ฐฑ์ค 10866 - ๋ฑ (0) | 2021.05.05 |
[ ํ์ด์ฌ(python) ] ๋ฐฑ์ค 18258 - ํ (0) | 2021.05.04 |
๋๊ธ