Notes

栈的模板

class Stack(object):
    def __init__(self):
        self.items = []

    def empty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def top(self):
        return self.items[-1]

    def size(self):
        return len(self.items)

    def clear(self):
        self.items = []

1:有效的括号

class Stack(object):
    def __init__(self):
        self.items = []

    def empty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def top(self):
        return self.items[-1]

    def size(self):
        return len(self.items)

    def clear(self):
        self.items = []

s = Stack()
str = input()
for it in str:
    if it == '{' or it == '[' or it == '(':
        s.push(it)
    else :
        if s.empty() == True :
            print("False")
            exit(0)
        if (it == '}' and s.top() == '{') or (it ==')' and s.top() =='(') or (it == ']' and s.top() == '[' ):
            s.pop()
            continue
        print("False")
        exit(0)
if( s.empty() ) :
    print("True")
else:
    print("False")

2:一维开心消消乐

class Stack(object):
    def __init__(self):
        self.items = []

    def empty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def top(self):
        return self.items[-1]

    def size(self):
        return len(self.items)

    def clear(self):
        self.items = []


s = Stack()
str = input()
for it in str:
    if s.empty() == 1 :
        s.push(it)
    elif it == s.top() :
        s.pop()
    else:
        s.push(it)

if s.empty() :
    print("None")
    exit(0)

for it in s.items:
    print(it,end='')

3:强迫症老板和他的洗碗工

这里我用栈A来维护当前的元素，栈B来维护已经被取出的元素。

首先如果栈B是空的，那么就说明没有元素被取出，我可以先把[0,x]放入 A 中，然后把元素x取出再重新放入 B 中。

剩下的情况就是 B 不是空的，首先判断如果要取出的元素比最后一次取出的元素大，那么我们就把[B.top,x]放入 A 中然后把x取出放入B中。

如果x比B.top小，那么可以确定是，[0,B.top]一定全部进入过A中，那么如果A.top是x的话x+1一定已经从A中出来进入B中，否则就是不合法的情况

然后发现整个过程中是不需要维护A的

class Stack(object):
    def __init__(self):
        self.items = []

    def empty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def top(self):
        return self.items[-1]

    def size(self):
        return len(self.items)

    def clear(self):
        self.items = []
    def count(self , val ):
        for i in self.items :
            if i == val :
                return True
        return False

def wash( ve ):
    stk = Stack()
    for it in ve:
        if stk.empty():
            stk.push(it)
        elif it < stk.top() :
            if stk.count(it+1) == False :
                return "No"
            else :
                stk.push(it)
        else:
            stk.push(it)
    return "Yes"

ve = []
for it in input():
    ve.append( int(it)  )

print(wash(ve))

Notes

栈的模板

class Stack(object):
    def __init__(self):
        self.items = []

    def empty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def top(self):
        return self.items[-1]

    def size(self):
        return len(self.items)

    def clear(self):
        self.items = []

1:有效的括号

class Stack(object):
    def __init__(self):
        self.items = []

    def empty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def top(self):
        return self.items[-1]

    def size(self):
        return len(self.items)

    def clear(self):
        self.items = []

s = Stack()
str = input()
for it in str:
    if it == '{' or it == '[' or it == '(':
        s.push(it)
    else :
        if s.empty() == True :
            print("False")
            exit(0)
        if (it == '}' and s.top() == '{') or (it ==')' and s.top() =='(') or (it == ']' and s.top() == '[' ):
            s.pop()
            continue
        print("False")
        exit(0)
if( s.empty() ) :
    print("True")
else:
    print("False")

2:一维开心消消乐

class Stack(object):
    def __init__(self):
        self.items = []

    def empty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def top(self):
        return self.items[-1]

    def size(self):
        return len(self.items)

    def clear(self):
        self.items = []


s = Stack()
str = input()
for it in str:
    if s.empty() == 1 :
        s.push(it)
    elif it == s.top() :
        s.pop()
    else:
        s.push(it)

if s.empty() :
    print("None")
    exit(0)

for it in s.items:
    print(it,end='')

3:强迫症老板和他的洗碗工

这里我用栈A来维护当前的元素，栈B来维护已经被取出的元素。

首先如果栈B是空的，那么就说明没有元素被取出，我可以先把[0,x]放入 A 中，然后把元素x取出再重新放入 B 中。

剩下的情况就是 B 不是空的，首先判断如果要取出的元素比最后一次取出的元素大，那么我们就把[B.top,x]放入 A 中然后把x取出放入B中。

如果x比B.top小，那么可以确定是，[0,B.top]一定全部进入过A中，那么如果A.top是x的话x+1一定已经从A中出来进入B中，否则就是不合法的情况

然后发现整个过程中是不需要维护A的

class Stack(object):
    def __init__(self):
        self.items = []

    def empty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def top(self):
        return self.items[-1]

    def size(self):
        return len(self.items)

    def clear(self):
        self.items = []
    def count(self , val ):
        for i in self.items :
            if i == val :
                return True
        return False

def wash( ve ):
    stk = Stack()
    for it in ve:
        if stk.empty():
            stk.push(it)
        elif it < stk.top() :
            if stk.count(it+1) == False :
                return "No"
            else :
                stk.push(it)
        else:
            stk.push(it)
    return "Yes"

ve = []
for it in input():
    ve.append( int(it)  )

print(wash(ve))

原文地址：https://www.cnblogs.com/PHarr/p/16573687.html