๋ฉด์ ์์ ์ข ์ข ๋์ค๋ ๋ฌธ์ ์ด๋ค. "์คํ๊ณผ ํ์ ์ฐจ์ด๋ ๋ฌด์์ธ๊ฐ?" ์ ๊ฐ์ ํํ๋ก ์คํ์ ํ์ ์ ์ถ์ ํํ๋ก ์๋ฃ์ ์ ์ถ๋ ฅ์ด ์ผ์ด๋๋ค. A,B,C,D ์์๋ก ์ ๋ ฅํ๋ค๋ฉด ๊บผ๋ผ ๋๋ D, C, B, A๋ก๋ง ๊บผ๋ผ ์ ์๋ค. ์ด๋ ์์ ๋๊ป(ํ๋จ)๋ง์ ์ด์ด๋ ๊ตฌ์กฐ์ ๊ฐ๋ค. ์ด๋ฆฐ ๊ณณ์ ๋ณดํต ์คํ ์๋จ(top)์ด๋ผ ๋ถ๋ฅธ๋ค. ๊ทธ๋์ ์ฝ์ ๊ณผ ์ญ์ ๋ ์๋จ์ผ๋ก๋ง ๊ฐ๋ฅํ๋ฉฐ ์ค๊ฐ์ผ๋ก์ ์ฝ์ ๊ณผ ์ญ์ ๋ ๋ถ๊ฐํ๋ค.
์ฒจ ๋ค์ด์จ ์ ๊ฐ ์ด๋ป๊ฒ ๋จผ์ ๋๊ฐ!๋ผ๊ณ ์๊ฐํ ์ ์์ง๋ง ์ญ์์ผ๋ก ์ด๋ค์ ธ์ผ ํ ์ถ๋ ฅ์์ ์๊ธดํ๊ฒ ์ฌ์ฉ๋๋ค.
์คํํญ๋ชฉ๋ค์ ์ ์ฅํ๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ ๋ฐฐ์ด ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉ. ํ์ด์ฌ์์๋ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ๋ค. ์ด๋ฆ์ top์ด๋ผ ํ์. ์ด ๋ฆฌ์คํธ๋ ๊ณต๋ฐฑ์ด ๋์ด์ผ ํ๋ค.
isEmpty() : ๊ณต๋ฐฑ ์ํ ๊ฒ์ฌ
def isEmpty(): return len(top) == 0 #len(top) == 0 ์ด T/F
push(item): ์ฝ์ ์ฐ์ฐ
์ฝ์ ์ ์คํ์ ์๋จ์ ํญ๋ชฉ์ ์ถ๊ฐํ๋ ๊ฒ์ด๋ค. ์๊ฐ ๋ณต์ก๋๋ฅผ ์๊ฐํ๋ฉด ๋งจ ๋ค์ ์คํ์ ์๋จ์ผ๋ก ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.def push(item): top.append(item)
pop(): ์ญ์ ์ฐ์ฐ
์ญ์ ์ฐ์ฐ์ ์คํ ์๋จ์ ํญ๋ชฉ์ ํ๋ ๊บผ๋ด๊ณ ์ด๋ฅผ ๋ฐํ. ํ์ด์ฌ์ ํญ๋ชฉ์ ๊บผ๋ด๋ pop(์์น) ์ฐ์ฐ์ ์ ๊ณต. ๋งค๊ฐ๋ณ์๋ก ๊บผ๋ผ ํญ๋ชฉ์ ์์น๋ฅผ ์ ๋ฌํด์ผ ํ๋ค. -1์ ๋งจ ๋ค์ ํญ๋ชฉ์ ๊บผ๋ธ๋ค.def pop(): if not isEmpty(): #๐ฅ๐ฅ๐ฅ์ญ์ ๋ ๊ณต๋ฐฑ ๊ฒ์ฌ ๊ผญ ํด์ค!๐ฅ๐ฅ๐ฅ return top.pop(-1)
์ญ์ ์ฐ์ฐ๋ ํญ์ O(1)์ ์ฒ๋ฆฌ๋๋ค. ๋ง ์ด๋ํ๊ณ ๊ทธ๋ด ํ์ ์๊ธฐ ๋๋ฌธ์ ๊ทธ๋ ๋ค. ์ต์ํจ์ ์์ ์์คํ ๊ณต๋ฐฑ ๊ฒ์ฌ๋ฅผ ์์ง ๋ง์! (๊ณผ์ ๋ ์
ค์์ ๊ฐ์ ๋ ๊ทธ๋ ์ง๋ง ์ฝ๋๋,, ๋ฌธ์ ๊ฐ ์๊ธด๋ค)
๋๋จธ์ง ์ฐ์ฐ๋ค๋ ๊ฐ๋จํ ๊ตฌํ๋๋ค. peek๋ ๋ฆฌ์คํธ์ ๋ง์ง๋ง ํญ๋ชฉ์ ๋ฐํํ๋ฉด๋๋ค. ์คํ ๋ด์ฉ์๋ ๋ณํ๊ฐ ์๋ค. ๋ฌผ๋ก ์ด ๊ฒฝ์ฐ์๋ ๊ณต๋ฐฑ์ด ์๋์ด์ผ ํ๋ค.
def peek(): #๋งจ ์์ ํญ๋ชฉ์ ์ญ์ ํ์ง ์๊ณ ๋ฐํ
if not isEmpty():
return top[-1]
์ฌ๋ฌ ๊ฐ์ ์คํ์ด ํ์ํด์ง ์ ์๊ธฐ์ ํด๋์ค๋ก ์ ์ธํด์ฃผ์.
โ ๏ธ ์ฃผ์! โ ๏ธ
- ์์ฑ์์ ํด๋์ค์ ๋ฐ์ดํฐ ๋ฉค๋ฒ๋ฅผ ์ ์ธํ๊ณ ์ด๊ธฐํ. ์คํ์ ์ ์ผํ ๋ฐ์ดํฐ์ธ top์ ๋ฆฌ์คํธ๋ก ์ ์ธ
- ๋ชจ๋ ๋ฉ์๋์ ์ฒซ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ๋ก self๋ฅผ ์ถ๊ฐ
- ๋ชจ๋ ๋ฉ์๋์์ ํด๋์ค์ ๋ฉค๋ฒ๋ฅผ ์ฌ์ฉํ ๋ self.์ ์ถ๊ฐํ์ฌ ํด๋์ค ๋ด์ ๋ณ์(๋ฐ์ดํฐ ๋ฉค๋ฒ) ๋ฐ ํจ์(๋ฉ์๋)์์ ํ์ํ๋ค.
class stack
def __init__(self): #์์ฑ์
self.top = [] #์ด๊ธฐํ
def isEmpty(self): return len(self.top) == 0 #๋น์๋น
def size(self): return len(sel.top) #๋ค์๋น
def clear(self) : return self.top = [] #๋ค์ ์ด๊ธฐํ
def push(self, item):
self.top.append(item)
def pop(self):
if not isEmpty():
return self.top.pop(-1)
def peek(self):
if not isEmpty():
return self.top[-1]
๐ฅ ์ด์ ๋ชจ๋ ์์ ์๊ฐ ๊ฑธ๋ฆผ ๐ฅ
์ดํ์ ์ฐ๋ ค๋ฉด? S = stack()์ฒ๋ผ ๋ถ๋ฌ์ค๊ณ
for i in range(10):
S.push(i)
๋ฑ์ผ๋ก ์จ์ฃผ๋ฉด ๋จ!
๊ดํธ๋ ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฑฐ๋ฆฌ์ ์๋ ๊ดํธ๋ผ๋ฆฌ ์๋ก ์์ ์ด๋ค์ผ ํจ์ ์ ์ ์๋ค. ์ฐ์ ์ ์ฑ ์์์ ๊ตฌํ์ ์ดํด๋ณด๊ณ ๋น์ทํ ์์ ๋ก ๋ฐฑ์ค์๋ ์์๋ค. ์ฌ๊ธฐ์๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ importํด์ ํด๊ฒฐํด๋ด!
def checkBrackets(state):
s = Stack()
for ch in state:
if ch in ('{', '[', '('):
stack.push(ch)
elif ch in ('}', ']', ')'):
if s.isEmpty():
return False #๋น์์ผ๋ฉด ์ํ๋
else: # ๐ฅelse๋ ๋น์ด์์ง ์์ผ๋ฉด์ ์๋ฏธ! ๋ค์ฌ์ฐ๊ธฐ ์กฐ์ฌ
left = s.pop()
if (ch == '}' and left !='{') or
if (ch == ']' and left !='[') or
(ch == ')' and left !='(') #๊ดํธ๊ฐ ์ง์ง์ด์ง์ง ์์๋ค๋ฉด
return False
return s.isEmpty()
์ด๊ฑด ๋ฐฐ์ด๊ฑฐ๊ตฌ ์ด์ ์ ์ฉํด๋ณด์.
์ ๋ฌธ์ ์ด๋ค
๊ดํธ ๋ฌธ์์ด(Parenthesis String, PS)์ ๋ ๊ฐ์ ๊ดํธ ๊ธฐํธ์ธ โ(โ ์ โ)โ ๋ง์ผ๋ก ๊ตฌ์ฑ๋์ด ์๋ ๋ฌธ์์ด์ด๋ค. ๊ทธ ์ค์์ ๊ดํธ์ ๋ชจ์์ด ๋ฐ๋ฅด๊ฒ ๊ตฌ์ฑ๋ ๋ฌธ์์ด์ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด(Valid PS, VPS)์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ํ ์์ ๊ดํธ ๊ธฐํธ๋ก ๋ โ( )โ ๋ฌธ์์ด์ ๊ธฐ๋ณธ VPS ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ๋ง์ผ x ๊ฐ VPS ๋ผ๋ฉด ์ด๊ฒ์ ํ๋์ ๊ดํธ์ ๋ฃ์ ์๋ก์ด ๋ฌธ์์ด โ(x)โ๋ VPS ๊ฐ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ VPS x ์ y๋ฅผ ์ ํฉ(concatenation)์ํจ ์๋ก์ด ๋ฌธ์์ด xy๋ VPS ๊ฐ ๋๋ค. ์๋ฅผ ๋ค์ด โ(())()โ์ โ((()))โ ๋ VPS ์ด์ง๋ง โ(()(โ, โ(())()))โ , ๊ทธ๋ฆฌ๊ณ โ(()โ ๋ ๋ชจ๋ VPS ๊ฐ ์๋ ๋ฌธ์์ด์ด๋ค. ์ฌ๋ฌ๋ถ์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๊ดํธ ๋ฌธ์์ด์ด VPS ์ธ์ง ์๋์ง๋ฅผ ํ๋จํด์ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ YES ์ NO ๋ก ๋ํ๋ด์ด์ผ ํ๋ค.
num = int(input())
for i in range(num):
stack = [] #์ด๊ธฐํ
state = input() #๋ฐ์์ค๊ธฐ
for toke in state:
if token == '(':
stack.append (token)
elif token == ')':
if stack:
stack.pop()
else:
print("NO")
breack
else:
if not stack: print('Yes')
else : print('NO')
์๋ ๊ฒ ํด๊ฒฐํ๋ค. ์ค์ ํ ์คํธ๋ ์ดํ์๋ ๋ณ์๋ช ์ ์ข ๋ ์ถ์ฝํด์ผ๊ฒ ๋ค.
def evalPost(exp):
s = Stack()
for token in exp:
if token in "+-*/": ์ฐ์ฐ์์ ๋ค์ด ์๋ค๋ฉด
val2 = s.pop() #ํผ์ฐ์ฐ์2
val1 = s.pop() #ํผ์ฐ์ฐ์1
if(token == '+'): s.push(val1 + val2)
elif(token == '-'): s.push(val1 - val2)
elif(token == '*'): s.push(val1 * val2)
elif(token == '/'): s.push(val1 / val2)
#์ฐ์ฐ ์ํ, ๊ฒฐ๊ณผ๋ ์คํ์ ๋ค์ ์ ์ฅ
else: #ํญ๋ชฉ์ด ํผ์ฐ์ฐ์์ด๋ฉด
s.push(float(token)) #์ค์๋ก ๋ณ๊ฒฝํด์ ์คํ์ ์ ์ฅ
return s.pop() #์ต์ข
๊ฒฐ๊ณผ๋ฅผ ๋ฐํ
def precedence(op):
if op == '(' or op==')' : return 0 #๊ดํธ๋ฅผ ๊ฐ์ฅ ๋ฎ๊ฒ
elif op == '+' or op == '-' : return 1
elif op == '*' or op == '/' : return 2
else: return -1
๋จผ์ ์ฐ์ฐ์๋ค์ ์ฐ์ ์์๋ฅผ ์ ํ๋ ํจ์๋ฅผ ๊ตฌํํด์ผ ํ๋ค. ์ฌ๋ ๊ดํธ๋ ์๊ธฐ ์ํด์ ์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋ฎ์์ผ ํ๋ฏ๋ก 0์ ๋ฐํ. + - ๋ ์ฐ์ ์์๊ฐ 1, * / ์ ์ ค ๋์ 2 ๋ถ์ฌ.
def Infixpost(exp):
s = Stack()
output = []
for term in expr :
if term in '(':
s.push('(')
elif term in ')':
while not s.isEmpty():
op = s.pop()
if op == '(' : break; #์ผ์ชฝ ๊ดํธ๊ฐ ๋์ฌ ๋๊น์ง ๊ณ์ ๋๋ด!
else :
output.append(op)
elif term in "+-*/": #์ฐ์ฐ์์ด๋ฉด
while not s.isEmpty(): #๋น์ง ์์์ ๋
op = s.peek() #์คํ์์ ๋ชจ๋ ๊บผ๋ด
if(precedence(term) <= precedence(op)):
#์ฐ์ ์์๊ฐ ๋๊ฑฐ๋ ๊ฐ์ ์ฐ์ฐ์๋ฅผ
output.append(op)
s.pop()
else:break
s.push(term)
else:
output.append(term)
while not s.isEmpty():
output.apppend(s.pop())
return output