小红书：笔试题（20190903）

笔记草稿

设置标志位flag判断是否进入注释部分，注释的开始和取消来自于栈comment的实现。

def backup_note(seq):
    res = []
    comment = []
    flag = False
    for su in seq:
        if not flag:
            if su.islower():
                res.append(su)
            elif su == '<':
                if res:
                    res.pop()
            elif su == '(':
                comment.append(su)
                flag = True
        else:
            if su == '(':
                comment.append(su)
            elif su == ')':
                comment.pop()
                if not comment:
                    flag = False
    return res


if __name__ == '__main__':
    seq = list(input().strip())
    res = backup_note(seq)
    print(''.join(res))

迷宫游戏

采用层次遍历，向外发散，逐层淹过。笔试的时候是通过额外的self.all集合来进行筛选的，最终结果是54%(超时)。想了想，可以设置为其他符号避免再次访问即可。

from collections import deque


class Solution:
    def __init__(self):
        self.res = []
        self.matrix = None
        self.t_row = None
        self.t_col = None

    def explore_game(self, seq, n):
        if self.matrix is None:
            self.matrix = seq
        sr, sc = self.find_start(n)
        self.t_row, self.t_col = self.find_end(n)
        return self.moving(sr, sc, n)

    def find_start(self, n):
        for row in range(n):
            for col in range(n):
                if self.matrix[row][col] == 'S':
                    return row, col

    def find_end(self, n):
        for row in range(n):
            for col in range(n):
                if self.matrix[row][col] == 'E':
                    return row, col

    def moving(self, row, col, n):
        visited = deque()
        visited.append([(row, col)])
        count = 0
        while visited:
            current = visited.pop()
            values = set()
            for cu in current:
                r, c = cu[0], cu[1]
                if r == self.t_row and c == self.t_col:
                    return count
                if self.matrix[(r+1)%n][c] in '.E':
                    values.add(((r+1)%n, c))
                    self.matrix[(r + 1) % n][c] = '*'
                if self.matrix[(r-1)%n][c] in '.E':
                    values.add(((r-1)%n, c))
                    self.matrix[(r - 1) % n][c] = '*'
                if self.matrix[r][(c+1)%n] in '.E':
                    values.add((r, (c+1)%n))
                    self.matrix[r][(c + 1) % n] = '*'
                if self.matrix[r][(c-1)%n] in '.E':
                    values.add((r, (c-1)%n))
                    self.matrix[r][(c - 1) % n] = '*'
            visited.append(list(values))
            count += 1
        return -1


if __name__ == '__main__':
    n = int(input().strip())
    seq = []
    for _ in range(n):
        seq.append([iu for iu in input().strip()])
    st = Solution()
    print(st.explore_game(seq, n))

倒卖战利品

建立元组列表依次追加输入宝物的稀有度和实用度组成的元组，通过集合化排除相同的宝物干扰，按照第一个元素即稀有度排序，之后的问题便是一个最长递增子序列LIS问题了。最终结果是64%(超时)。

from bisect import bisect


def profit(seq):
    if not seq:
        return 0
    seq = list(set(seq))
    seq.sort()
    
    values = [su[1] for su in seq]
    end = []
    for val in values:
        idx = bisect(end, val)
        if idx == len(end):
            end.append(val)
        else:
            end[idx] = val
    return len(end)


if __name__ == '__main__':
    n = int(input().strip())
    seq = []
    for _ in range(n):
        seq.append(tuple(map(int, input().strip().split())))
    res = profit(seq)
    print(res)

（最近更新：2019年09月03日）