20. Valid Parentheses 合法括号（Easy）

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

  1. Open brackets must be closed by the same type of brackets.
  2. Open brackets must be closed in the correct order.

Note that an empty string is also considered valid.

Example 1:

Input: "()"
Output: true

Example 2:

Input: "()[]{}"
Output: true

Example 3:

Input: "(]"
Output: false

Example 4:

Input: "([)]"
Output: false

Example 5:

Input: "{[]}"
Output: true

栈Stack，经典的使用栈的题目。遍历字符串，如果为左括号，将其压入栈中，如果遇到为右括号，若此时栈为空，则直接返回false，如不为空，则取出栈顶元素，若为对应的左括号，是合法的继续循环，否则返回false。

class Solution(object):def isValid(self, s):""":type s: str:rtype: bool"""stack = []    #建立一个栈dict = {"]":"[", "}":"{", ")":"("}   #建立一个字典，成对应关系for char in s:     #循环if char in dict.values():   #如果在字符串中有左括号，就将这个字符添加在栈中stack.append(char)    elif char in dict.keys():   #如果字符中有右括号if stack == [] or dict[char] != stack.pop():      #如果栈是空的或者是这个字符对应的值不等于栈中取出的字符，就返回falsereturn Falseelse:return Truereturn stack == []   #如果最后栈为空就返回True
class Solution(object):def isValid(self, s):""":type s: str:rtype: bool"""stack, lookup = [], {"(": ")", "{": "}", "[": "]"}for parenthese in s:if parenthese in lookup:  # Cannot use if lookup[parenthese]: KeyErrorstack.append(parenthese)elif len(stack) == 0 or lookup[stack.pop()] != parenthese: # Cannot use not stackreturn Falsereturn len(stack) == 0
class Solution(object):def isValid(self, s):""":type s: str:rtype: bool"""stack = []m = {'(': ')', '[': ']', '{': '}'}n = [')', ']', '}']for i in s:if i in m:stack.append(i)elif i in n and stack:if m[stack.pop()] != i:return Falseelse:return Falsereturn len(stack) == 0

71. Simplify Path 简化路径（Medium）

Given an absolute path for a file (Unix-style), simplify it. Or in other words, convert it to the canonical path.

In a UNIX-style file system, a period . refers to the current directory. Furthermore, a double period .. moves the directory up a level. For more information, see: Absolute path vs relative path in Linux/Unix

Note that the returned canonical path must always begin with a slash /, and there must be only a single slash / between two directory names. The last directory name (if it exists) must not end with a trailing /. Also, the canonical path must be the shortest string representing the absolute path.

Example 1:

Input: "/home/"
Output: "/home"
Explanation: Note that there is no trailing slash after the last directory name.

Example 2:

Input: "/../"
Output: "/"
Explanation: Going one level up from the root directory is a no-op, as the root level is the highest level you can go.

Example 3:

Input: "/home//foo/"
Output: "/home/foo"
Explanation: In the canonical path, multiple consecutive slashes are replaced by a single one.

Example 4:

Input: "/a/./b/../../c/"
Output: "/c"

Example 5:

Input: "/a/../../b/../c//.//"
Output: "/c"

Example 6:

Input: "/a//bc/d//././/.."
Output: "/a/b/c"

1、".."表示跳到上一层目录，删掉它上面挨着的一个路径。

2、"."表示当前目录，直接去掉。

3、如果有多个"/"只保留一个。

4、如果最后有一个"/"，去掉不要。

class Solution(object):def simplifyPath(self, path):""":type path: str:rtype: str"""stack, tokens = [], path.split("/")   #建立一个栈， split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串。参数（str：分隔符，num:分割次数，默认-1，即分割所有），返回分割后的字符串列表，不带有分隔符。本函数将字符串根据/分割成一段一段的。for token in tokens:   if token == ".." and stack:    #如果列表的值是..且栈不为空，stack.pop()    #就取出最上边的一个值elif token != ".." and token != "." and token:    #如果列表的字符不是..且字符不是.，且列表值为真，stack.append(token)   #就将这个值压入栈return "/" + "/".join(stack)  #join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

388. Longest Absolute File Path 最长的绝对文件路径 （Medium）

Suppose we abstract our file system by a string in the following manner:

The string "dir\n\tsubdir1\n\tsubdir2\n\t\tfile.ext" represents:

dirsubdir1subdir2file.ext

The directory dir contains an empty sub-directory subdir1 and a sub-directory subdir2 containing a file file.ext.

The string "dir\n\tsubdir1\n\t\tfile1.ext\n\t\tsubsubdir1\n\tsubdir2\n\t\tsubsubdir2\n\t\t\tfile2.ext"represents:

dirsubdir1file1.extsubsubdir1subdir2subsubdir2file2.ext

The directory dir contains two sub-directories subdir1 and subdir2. subdir1 contains a file file1.ext and an empty second-level sub-directory subsubdir1. subdir2 contains a second-level sub-directory subsubdir2 containing a file file2.ext.

We are interested in finding the longest (number of characters) absolute path to a file within our file system. For example, in the second example above, the longest absolute path is "dir/subdir2/subsubdir2/file2.ext", and its length is 32 (not including the double quotes).

Given a string representing the file system in the above format, return the length of the longest absolute path to file in the abstracted file system. If there is no file in the system, return 0.

Note:

  • The name of a file contains at least a . and an extension.
  • The name of a directory or sub-directory will not contain a ..

Time complexity required: O(n) where n is the size of the input string.

Notice that a/aa/aaa/file1.txt is not the longest file path, if there is another path aaaaaaaaaaaaaaaaaaaaa/sth.png.

解法1：栈Stack

一个字符串表示文件系统的目录结构，里面包含\n(回车)和\t(tab)的特殊字符，要找到最长的绝对文件路径。
可用栈Stack, Array, Hash table来保存每一层的最长路径长度。以栈为例：

1. 将字符串以'\n'进行拆分，得到目录字符串数组，设置最大长度变量 maxLen = 0，设置一个 Stack，初始设为0层为0。

2. 对这个数组迭代，对于每个目录字符串统计其前面的'\t'个数， 个数加1就是当前目录的层深度，比如： 0个'\t'，层数就是1，1个'\t'，层数是2。

3. 比较当前目录层数和栈顶层数：

1）如果目录层数大于栈顶层数：判断是否含'.' ，

a. 不含'.'，则是目录，计算当前目录长度（字符长度+1因为要多1个"/"）+ 上层目录最大长度，长度入栈。

b. 含'.' , 则为文件，计算当前文件长度（字符长度），此长度加上栈顶元素长度（上层目录最大长度）和maxLen比较取最大。

2）如果目录层数小于栈顶层数：

则弹出栈顶元素，用while循环，一直弹到栈顶的层小于当前层数。然后重复上面的a, b步骤

最后，返回maxLen.

解法2：哈希表HashMap

class Solution(object):def lengthLongestPath(self, input):""":type input: str:rtype: int"""maxlen = 0pathlen = {0: 0}for line in input.splitlines():   #splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符，默认为false。返回一个包含各行作为元素的列表。name = line.lstrip('\t')    #lstrip([chars]) 方法用于截掉字符串左边的空格或指定字符。chars --指定截取的字符。返回新的字符串depth = len(line) - len(name)if '.' in name:    #如果name中有.maxlen = max(maxlen, pathlen[depth] + len(name))else:pathlen[depth + 1] = pathlen[depth] + len(name) + 1return maxlen

394. Decode String 解码字符串 （Medium）

Given an encoded string, return it's decoded string.

The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times. Note that k is guaranteed to be a positive integer.

You may assume that the input string is always valid; No extra white spaces, square brackets are well-formed, etc.

Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, k. For example, there won't be input like 3a or 2[4].

Examples:

s = "3[a]2[bc]", return "aaabcbc".
s = "3[a2[c]]", return "accaccacc".
s = "2[abc]3[cd]ef", return "abcabccdcdcdef".
class Solution(object):def decodeString(self, s):""":type s: str:rtype: str"""curnum = 0curstring = ''stack = []for char in s:if char == '[':    #如果字符是[stack.append(curstring)     #把当前字符压入栈stack.append(curnum)    #把当前数字压入栈curstring = ''    #重新赋值curstring  和curstringcurnum = 0  elif char == ']':      #如果字符是]prenum = stack.pop()   #取出上边的字符和数字prestring = stack.pop()  curstring = prestring + prenum * curstringelif char.isdigit():    #isdigit() 方法检测字符串是否只由数字组成。只包含数字返回True，否则返回False。curnum = curnum * 10 + int(char)   #这里存在的目的是当[前面是一个好几位的数时的情况else:curstring += charreturn curstring

341. Flatten Nested List Iterator  展平嵌套列表迭代器  （Medium）

Given a nested list of integers, implement an iterator to flatten it.

Each element is either an integer, or a list -- whose elements may also be integers or other lists.

Example 1:

Input: [[1,1],2,[1,1]]
Output: [1,1,2,1,1]
Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be:
[1,1,2,1,1]
.

Example 2:

Input: [1,[4,[6]]]
Output: [1,4,6]
Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be:[1,4,6]。

将1个含有整数元素的嵌套链表压平，就是把所以元素按嵌套关系变成1个list。按题目要求要有next和hasNext两个函数。（这个题没搞明白）

# """
# This is the interface that allows for creating nested lists.
# You should not implement it, or speculate about its implementation
# """
#class NestedInteger(object):
#    def isInteger(self):
#        """
#        @return True if this NestedInteger holds a single integer, rather than a nested list.
#        :rtype bool
#        """
#
#    def getInteger(self):
#        """
#        @return the single integer that this NestedInteger holds, if it holds a single integer
#        Return None if this NestedInteger holds a nested list
#        :rtype int
#        """
#
#    def getList(self):
#        """
#        @return the nested list that this NestedInteger holds, if it holds a nested list
#        Return None if this NestedInteger holds a single integer
#        :rtype List[NestedInteger]
#        """class NestedIterator(object):def __init__(self, nestedList):"""Initialize your data structure here.:type nestedList: List[NestedInteger]"""self.stack = []self.list = nestedListdef next(self):""":rtype: int"""return self.stack.pop()def hasNext(self):""":rtype: bool"""while self.list or self.stack:    #当列表和栈都不为空时，if not self.stack:      #如果栈为空，就把链表中第一个数取出来放在栈里边self.stack.append(self.list.pop(0))              while self.stack and not self.stack[-1].isInteger():     #isInteger()判断是否为整数。-1：最后一个数。如果栈不为空，且最后一个数不是整数。top = self.stack.pop().getList()for e in top[::-1]:self.stack.append(e)if self.stack and self.stack[-1].isInteger():return Truereturn False# Your NestedIterator object will be instantiated and called as such:
# i, v = NestedIterator(nestedList), []
# while i.hasNext(): v.append(i.next())

150. Evaluate Reverse Polish Notation 计算逆波兰表达式 （Medium）

Evaluate the value of an arithmetic expression in Reverse Polish Notation.

Valid operators are +, -, *, /. Each operand may be an integer or another expression.

Note:

  • Division between two integers should truncate toward zero.
  • The given RPN expression is always valid. That means the expression would always evaluate to a result and there won't be any divide by zero operation.

Example 1:

Input: ["2", "1", "+", "3", "*"]
Output: 9
Explanation: ((2 + 1) * 3) = 9

Example 2:

Input: ["4", "13", "5", "/", "+"]
Output: 6
Explanation: (4 + (13 / 5)) = 6

Example 3:

Input: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
Output: 22
Explanation: ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

逆波兰表达式，所有操作符置于操作数的后面，因此也被称为后缀表示法。逆波兰记法不需要括号来标识操作符的优先级。

逆波兰记法中，操作符置于操作数的后面。例如表达“三加四”时，写作“3 4 +”，而不是“3 + 4”。如果有多个操作符，操作符置于第二个操作数的后面，所以常规中缀记法的“3 - 4 + 5”在逆波兰记法中写作“3 4 - 5 +”：先3减去4，再加上5。使用逆波兰记法的一个好处是不需要使用括号。例如中缀记法中“3 - 4 * 5”与“（3 - 4）*5”不相同，但后缀记法中前者写做“3 4 5 * -”，无歧义地表示“3 (4 5 *) -”；后者写做“3 4 - 5 *”。

逆波兰表达式的解释器一般是基于堆栈的。解释过程一般是：操作数入栈；遇到操作符时，操作数出栈，求值，将结果入栈；当一遍后，栈顶就是表达式的值。因此逆波兰表达式的求值使用堆栈结构很容易实现，并且能很快求值。

注意：逆波兰记法并不是简单的波兰表达式的反转。因为对于不满足交换律的操作符，它的操作数写法仍然是常规顺序，如，波兰记法“/ 6 3”的逆波兰记法是“6 3 /”而不是“3 6 /”；数字的数位写法也是常规顺序。

解法1: 栈Stack

解法2: 递归

class Solution(object):def evalRPN(self, tokens):""":type tokens: List[str]:rtype: int"""numerals, operators = [], {"+": operator.add, "-": operator.sub, "*": operator.mul, "/": operator.div}for token in tokens:if token not in operators:numerals.append(int(token))else:y, x = numerals.pop(), numerals.pop()numerals.append(int(operators[token](x * 1.0, y)))return numerals.pop()

385. Mini Parser  迷你解析器（Medium）

Given a nested list of integers represented as a string, implement a parser to deserialize it.

Each element is either an integer, or a list -- whose elements may also be integers or other lists.

Note: You may assume that the string is well-formed:

  • String is non-empty.
  • String does not contain white spaces.
  • String contains only digits 0-9, [, - ,, ].

Example 1:

Given s = "324",You should return a NestedInteger object which contains a single integer 324.

Example 2:

Given s = "[123,[456,[789]]]",Return a NestedInteger object containing a nested list with 2 elements:1. An integer containing value 123.
2. A nested list containing two elements:i.  An integer containing value 456.ii. A nested list with one element:a. An integer containing value 789.

给了一个字符串表示的列表，返回一个NestedInteger形式的列表，其每个元素都是NestedInteger形式的整数对象。

# """
# This is the interface that allows for creating nested lists.
# You should not implement it, or speculate about its implementation
# """
#class NestedInteger(object):
#    def __init__(self, value=None):
#        """
#        If value is not specified, initializes an empty list.
#        Otherwise initializes a single integer equal to value.
#        """
#
#    def isInteger(self):
#        """
#        @return True if this NestedInteger holds a single integer, rather than a nested list.
#        :rtype bool
#        """
#
#    def add(self, elem):
#        """
#        Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
#        :rtype void
#        """
#
#    def setInteger(self, value):
#        """
#        Set this NestedInteger to hold a single integer equal to value.
#        :rtype void
#        """
#
#    def getInteger(self):
#        """
#        @return the single integer that this NestedInteger holds, if it holds a single integer
#        Return None if this NestedInteger holds a nested list
#        :rtype int
#        """
#
#    def getList(self):
#        """
#        @return the nested list that this NestedInteger holds, if it holds a nested list
#        Return None if this NestedInteger holds a single integer
#        :rtype List[NestedInteger]
#        """class Solution(object):def deserialize(self, s):""":type s: str:rtype: NestedInteger"""def getNumber(nums):if isinstance(nums, int):return NestedInteger(nums)lst = NestedInteger()for num in nums:lst.add(getNumber(num))return lstreturn getNumber(eval(s))   #eval() 函数用来执行一个字符串表达式，并返回表达式的值。

155. Min Stack 最小栈 （Easy）

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.

  • push(x) -- Push element x onto stack.
  • pop() -- Removes the element on top of the stack.
  • top() -- Get the top element.
  • getMin() -- Retrieve the minimum element in the stack.

Example:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> Returns -3.
minStack.pop();
minStack.top();      --> Returns 0.
minStack.getMin();   --> Returns -2.

设计一个最小栈，实现push, pop, top, getMin四个功能。相比原来的栈多了一个功能，可以返回当前栈内的最小值。

解法1：使用2个栈，栈1记录进来的数，栈2记录目前的最小值。当有新数push进来的时候，如果栈2为空或者这个数小于栈2顶上的值，就把这个数推入栈2。当pop的数正好等于最小值时，说明当前栈内的最小值变化了，要弹出这个最小值，记录的下一个最小值来到栈顶。

解法2：只使用1个栈，用一个变量min_val记录当前的最小值，将当前最小值一同入栈，为节省空间，仅在当前最小值更改时才入栈。所以该栈的push和pop实际上可能是两次。当新进来的数小于min_val时，把当前的min_val和新进来的数一起推入到栈，min_val变为这个新进来的数。当pop栈顶元素的时候，如果栈顶元素的值和min_val相等，那么就把它下面记录的之前最小值赋给min_val并弹出。

解法3：也是使用1个栈，但栈中存的是当前值与最小值的差，用一个元素来记录，然后根据这个值可以计算出当前值和最小值。当栈顶元素为正时，表示当前元素比最小元素大，当前值为最小值+差值；当栈顶元素为负时，其表示的是当前元素值比之前最小值小，现在的最小值就是元素值。

要注意重复值的push和pop。

2Stack

class MinStack(object):def __init__(self):"""initialize your data structure here."""self.stack = []     #建立了两个栈self.minStack = []def push(self, x):""":type x: int:rtype: None"""self.stack.append(x)     #将得到 的数压入栈if len(self.minStack) == 0 or x <= self.minStack[-1]:  #如果最小栈为0 ，或者压入的数小于最小栈，就把这个数压入最小栈中self.minStack.append(x)def pop(self):""":rtype: None"""if self.top() == self.getMin():   #如果栈顶元素和最小栈最后一个数相等self.minStack.pop()      #删除最小栈最后一个值return self.stack.pop()     def top(self):""":rtype: int"""return self.stack[-1]      #返回栈最上边的一个数def getMin(self):""":rtype: int"""return self.minStack[-1]    #调用这个函数救就会将最小栈最后一个数返回# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

1Stack，最小值和元素一同入栈

class MinStack(object):def __init__(self):"""initialize your data structure here."""self.min = 2147483647self.stack = []     #建立了一个栈def push(self, x):""":type x: int:rtype: None"""if x <= self.min:  #如果要压入的元素小于等于最小值，就将最小值压入栈；self.stack.append(self.min)self.min = x           #min变为一个更小的值self.stack.append(x)   #否则将x压入栈中def pop(self):""":rtype: None"""peak = self.stack.pop()          #将栈中元素取出，赋值给peak，如果peak等于最小值，将取出的值赋值给最小值if peak == self.min:    #减产删除的元素是不是最小值，如果是的话，就将下一个数重新命名为最小值。self.min = self.stack.pop()   #def top(self):""":rtype: int"""return self.stack[-1]          #返回栈的最后一个元素def getMin(self):""":rtype: int"""return self.min     #返回最小值# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

232. Implement Queue using Stacks  使用堆栈实现队列（Easy）

Implement the following operations of a queue using stacks.

  • push(x) -- Push element x to the back of queue.
  • pop() -- Removes the element from in front of queue.
  • peek() -- Get the front element.
  • empty() -- Return whether the queue is empty.

Example:

MyQueue queue = new MyQueue();queue.push(1);
queue.push(2);
queue.peek();  // returns 1
queue.pop();   // returns 1
queue.empty(); // returns false

Notes:

  • You must use only standard operations of a stack -- which means only push to top, peek/pop from top, size, and is empty operations are valid.
  • Depending on your language, stack may not be supported natively. You may simulate a stack by using a list or deque (double-ended queue), as long as you use only standard operations of a stack.
  • You may assume that all operations are valid (for example, no pop or peek operations will be called on an empty queue).

用栈来实现队列，对比类似题目225. Implement Stack using Queues是反过来用。

class MyQueue(object):def __init__(self):"""Initialize your data structure here."""self.A = []   #建立两个栈self.B = []def push(self, x):"""Push element x to the back of queue.:type x: int:rtype: None"""self.A.append(x)    #将x压入栈中def pop(self):"""Removes the element from in front of queue and returns that element.:rtype: int"""self.peek()  #将栈A的值放在栈B中，然后删除最上边的元素，就是删除了队列最前边的元素return self.B.pop()     #返回删除上边元素的栈Bdef peek(self):"""Get the front element.:rtype: int"""if not self.B:      #如果B为空，当栈A不为空时，将栈A取出的元素加在B中；相当于调转一下位置，这样最下边的元素就成了最上边的元素。while self.A:self.B.append(self.A.pop())return self.B[-1]          #返回B最上边的值def empty(self):       """Returns whether the queue is empty.:rtype: bool"""return not self.A and not self.B   # Your MyQueue object will be instantiated and called as such:
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()

225. Implement Stack using Queues  用队列实现栈 （Easy）

Implement the following operations of a stack using queues.

  • push(x) -- Push element x onto stack.
  • pop() -- Removes the element on top of the stack.
  • top() -- Get the top element.
  • empty() -- Return whether the stack is empty.

Example:

MyStack stack = new MyStack();stack.push(1);
stack.push(2);
stack.top();   // returns 2
stack.pop();   // returns 2
stack.empty(); // returns false

Notes:

  • You must use only standard operations of a queue -- which means only push to back, peek/pop from front, size, and is empty operations are valid.
  • Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.
  • You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).

用队列Queues的基本操作来实现栈Stack，队列和栈都是重要的数据结构，区别主要是，队列是先进先出，而栈是先进后出。

解法1:  在队列push进来新元素时，就把其它元素pop出来排到新元素的后面，新元素就在前面了，就可以后进先出。就好像大家都在排队，来了个重要客人，要让他第一，其他人从前面按顺序跑到他后面。

解法2: push的时候，其他元素不动只是用一个变量记住这个新元素。当top的时候直接给这个变量的值。当pop时，在调整顺序，把最后一个排到前面，弹出。变量记住目前在最尾部的值。


class MyStack(object):def __init__(self):self._queue = collections.deque()   #利用collections模块建立一个deque的双向队列。def push(self, x):q = self._queueq.append(x)for _ in range(len(q) - 1):   #每压入一个数，都将前面的数字转移到队列的后边。因为是空列表所以这样做有效，如果一开始是非空列表就不管用了q.append(q.popleft())    #popleft（获取最左边一个元素，并在队列中删除），然后加在q中。def pop(self):return self._queue.popleft()def top(self):return self._queue[0]def empty(self):return not len(self._queue)# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

224. Basic Calculator  基本计算器 （Hard）

Implement a basic calculator to evaluate a simple expression string.

The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .

Example 1:

Input: "1 + 1"
Output: 2

Example 2:

Input: " 2-1 + 2 "
Output: 3

Example 3:

Input: "(1+(4+5+2)-3)+(6+8)"
Output: 23

Note:

  • You may assume that the given expression is always valid.
  • Do not use the eval built-in library function.

参考链接：https://blog.csdn.net/fuxuemingzhu/article/details/84133441

这个题没有乘除法，也就少了计算优先级的判断了。众所周知，实现计算器需要使用一个栈，来保存之前的结果，把后面的结果计算出来之后，和栈里的数字进行操作。

使用了res表示不包括栈里数字在内的结果，num表示当前操作的数字，sign表示运算符的正负，用栈保存遇到括号时前面计算好了的结果和运算符。

操作的步骤是：

如果当前是数字，那么更新计算当前数字；
如果当前是操作符+或者-，那么需要更新计算当前计算的结果res，并把当前数字num设为0，sign设为正负，重新开始；
如果当前是(，那么说明后面的小括号里的内容需要优先计算，所以要把res，sign进栈，更新res和sign为新的开始；
如果当前是)，那么说明当前括号里的内容已经计算完毕，所以要把之前的结果出栈，然后计算整个式子的结果；
最后，当所有数字结束的时候，需要把结果进行计算，确保结果是正确的。

class Solution(object):def calculate(self, s):""":type s: str:rtype: int"""res, num, sign = 0, 0, 1     #res表示不包括栈里数字在内的结果；num表示当前操作的数字；sign表示运算符的正负；stack = []          #用栈保存遇到括号是前面计算好了的结果和运算符；for c in s:if c.isdigit():num = 10 * num + int(c)elif c == "+" or c == "-":res = res + sign * numnum = 0sign = 1 if c == "+" else -1elif c == "(":stack.append(res)stack.append(sign)res = 0sign = 1elif c == ")":res = res + sign * numnum = 0res *= stack.pop()res += stack.pop()res = res + sign * numreturn res

227. Basic Calculator II  基本计算器II  （Medium）

Implement a basic calculator to evaluate a simple expression string.

The expression string contains only non-negative integers, +, -, *, / operators and empty spaces . The integer division should truncate toward zero.

Example 1:

Input: "3+2*2"
Output: 7

Example 2:

Input: " 3/2 "
Output: 1

Example 3:

Input: " 3+5 / 2 "
Output: 5

Note:

  • You may assume that the given expression is always valid.
  • Do not use the eval built-in library function.

直接使用eval可以过。。然后算法的话，使用下下面的方法：

用num保存上一个数字，用pre_op保存上一个操作符。当遇到新的操作符的时候，需要根据pre_op进行操作。乘除的优先级高于加减。所以有以下规则：

之前的运算符是+，那么需要把之前的数字num进栈，然后等待下一个操作数的到来。 
之前的运算符是-，那么需要把之前的数字求反-num进栈，然后等待下一个操作数的到来。 
之前的运算符是×，那么需要立刻出栈和之前的数字相乘，重新进栈，然后等待下一个操作数的到来。 
之前的运算符是/，那么需要立刻出栈和之前的数字相除，重新进栈，然后等待下一个操作数的到来。

注意比较的都是之前的操作符和操作数，现在遇到的操作符是没有什么用的。

另外，坑爹的Python地板除。。比如-3//2=2的，和c++不一样。因此真正操作的时候如果遇到负数，使用的用浮点除再取整的方式获得和c++一样的结果。
原文：https://blog.csdn.net/fuxuemingzhu/article/details/80826333

class Solution(object):def calculate(self, s):""":type s: str:rtype: int"""stack = []pre_op = '+'             #保存操作符num = 0for i, each in enumerate(s):   #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。if each.isdigit():num = 10 * num + int(each)if i == len(s) - 1 or each in '+-*/':if pre_op == '+':stack.append(num)elif pre_op == '-':stack.append(-num)elif pre_op == '*':stack.append(stack.pop() * num)elif pre_op == '/':top = stack.pop()if top < 0:stack.append(int(top / num))else:stack.append(top // num)pre_op = eachnum = 0return sum(stack)

直接使用eval可以过。。然后算法的话，使用下下面的方法：

用num保存上一个数字，用pre_op保存上一个操作符。当遇到新的操作符的时候，需要根据pre_op进行操作。乘除的优先级高于加减。所以有以下规则：

之前的运算符是+，那么需要把之前的数字num进栈，然后等待下一个操作数的到来。 
之前的运算符是-，那么需要把之前的数字求反-num进栈，然后等待下一个操作数的到来。 
之前的运算符是×，那么需要立刻出栈和之前的数字相乘，重新进栈，然后等待下一个操作数的到来。 
之前的运算符是/，那么需要立刻出栈和之前的数字相除，重新进栈，然后等待下一个操作数的到来。

注意比较的都是之前的操作符和操作数，现在遇到的操作符是没有什么用的。

另外，坑爹的Python地板除。。比如-3//2=2的，和c++不一样。因此真正操作的时候如果遇到负数，使用的用浮点除再取整的方式获得和c++一样的结果。
原文：https://blog.csdn.net/fuxuemingzhu/article/details/80826333

class Solution(object):def calculate(self, s):""":type s: str:rtype: int"""stack = []pre_op = '+'             #保存操作符num = 0for i, each in enumerate(s):   #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。if each.isdigit():num = 10 * num + int(each)if i == len(s) - 1 or each in '+-*/':if pre_op == '+':stack.append(num)elif pre_op == '-':stack.append(-num)elif pre_op == '*':stack.append(stack.pop() * num)elif pre_op == '/':top = stack.pop()if top < 0:stack.append((-1) * int((-1) * top / num))else:stack.append(top // num)pre_op = eachnum = 0return sum(stack)

42. Trapping Rain Water  收集雨水 （Hard）

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.


The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!

Example:

Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6

解法1：双指针Two Pointers，left和right分别指向数组的头尾，从两边向中间扫描，在当前两指针的范围内，先比较两头找出较小值，如果较小值是left指向的值，则从左向右扫描，如果较小值是right指向的值，则从右向左扫描，若遇到的值比当较小值小，则将差值存入结果，如遇到的值大，则重新确定新的窗口范围，迭代直至left和right指针重合。

对于任何一个坐标，检查其左右的最大坐标，然后相减就是容积。所以， 
1. 从左往右扫描一遍，对于每一个坐标，求取左边最大值。
2. 从右往左扫描一遍，对于每一个坐标，求最大右值。
3. 再扫描一遍，求取容积并加和。
2和3可以合并成一个循环，公式：H[i] = min(Max(Array[j] ),  Max(Array[k])) – Array[i]  where  j < i and k > i

解法2：栈stack

Follow up:

不求所有容积，而是求容积中的最大值。这样就类似于Container With Most Water，但是有不同的地方，这题里面每一个坐标本身是占体积的。所以从两边往中间扫的时候，根本不知道中间坐标共占用了多少体积。

来源：http://www.cnblogs.com/lightwindy/p/8495692.html

class Solution(object):def trap(self, A):""":type A: List[int]:rtype: int"""if not A:  #A为空，返回0return 0res = 0left, right = 0, len(A) - 1  #双指针法left_max, right_max = 0, 0while left < right:     if A[left] < A[right]:       #如果左端的值小于右端的值left_max = max(left_max, A[left])left += 1       #左边的指针向右移一个长度res += max(0, left_max - A[left])    #左边的指针移了一个长度的数值减去之前位置的数值，和0 比较else:right_max = max(right_max, A[right])right -= 1res += max(0, right_max - A[right])return res 
class Solution(object):def trap(self, A):""":type A: List[int]:rtype: int"""result = 0stack = []for i in xrange(len(A)):mid_height = 0while stack:[pos, height] = stack.pop()result += (min(height, A[i]) - mid_height) * (i - pos - 1)mid_height = heightif A[i] < height:stack.append([pos, height])breakstack.append([i, A[i]])return result

107. Binary Tree Level Order Traversal II   二叉树层序遍历 II （Easy）

Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3/ \9  20/  \15   7

return its bottom-up level order traversal as:

[[15,7],[9,20],[3]
]

102题的变形只是最后输出的顺序变了，这题是从最后一层开始。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution(object):def levelOrderBottom(self, root):""":type root: TreeNode:rtype: List[List[int]]"""if root is None:   #根节点如果为空，则返回空列表return []result, current = [], [root]   #while current:   #若这个列表不为空，就一直循环next_level, vals = [], []    for node in current:vals.append(node.val)if node.left:next_level.append(node.left)if node.right:next_level.append(node.right)current = next_levelresult.append(vals)   #加的时候不是一个一个加，是把上一个列表的值一块加到新的列表中。return result[::-1]   #将列表中的元素倒着输出

102. Binary Tree Level Order Traversal  二叉树层序遍历 （Medium）

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3/ \9  20/  \15   7

return its level order traversal as:

[[3],[9,20],[15,7]
]

给一棵二叉树，返回从左往右层序遍历的结果，每一层单独记录。有BFS(迭代Iteration)和DFS(递归Recursion)两种解法。

拓展：先序遍历preorder的递归做法加上一个层就是这题的DFS解法。


#迭代法
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution(object):    def levelOrder(self, root):""":type root: TreeNode:rtype: List[List[int]]"""if root is None:return []result, current = [], [root]while current:next_level, vals = [], []for node in current:vals.append(node.val)if node.left:next_level.append(node.left)if node.right:next_level.append(node.right)current = next_levelresult.append(vals)return result#递归法# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution(object):   def preorder(self, root, level, res):if root:if len(res) < level+1: res.append([])res[level].append(root.val)self.preorder(root.left, level+1, res)self.preorder(root.right, level+1, res)def levelOrder(self, root):res=[]self.preorder(root, 0, res)return res

496. Next Greater Element I   下一个较大元素  I （Easy）

You are given two arrays (without duplicates) nums1 and nums2 where nums1’s elements are subset of nums2. Find all the next greater numbers for nums1's elements in the corresponding places of nums2.

The Next Greater Number of a number x in nums1 is the first greater number to its right in nums2. If it does not exist, output -1 for this number.

Example 1:

Input: nums1 = [4,1,2], nums2 = [1,3,4,2].
Output: [-1,3,-1]
Explanation:
    For number 4 in the first array, you cannot find the next greater number for it in the second array, so output -1.
    For number 1 in the first array, the next greater number for it in the second array is 3.
    For number 2 in the first array, there is no next greater number for it in the second array, so output -1.

Example 2:

Input: nums1 = [2,4], nums2 = [1,2,3,4].
Output: [3,-1]
Explanation:
    For number 2 in the first array, the next greater number for it in the second array is 3.
    For number 4 in the first array, there is no next greater number for it in the second array, so output -1.

Note:

  1. All elements in nums1 and nums2 are unique.

  2. The length of both nums1 and nums2 would not exceed 1000.

解法：栈，递减栈。先求出nums2中所有元素的右边第一个较大数字的位置，并记录到map中。然后，因为nums1是子数组，循环nums1中的元素，记录在map中值并返回。求nums2中下一个较大元素时用递减栈，循环元素，当前元素大于栈顶元素时，就弹出栈顶元素，并记录栈顶元素下一个最大就是当前元素。然后继续比较栈顶元素，直到小于或等于栈顶元素。

G家followup: 如果data是stream data怎么改代码和设计输出。

class Solution(object):def nextGreaterElement(self, nums1, nums2):""":type nums1: List[int]:type nums2: List[int]:rtype: List[int]"""d = {}    #建立一个字典，两个列表st = []     ans = []   #存放最后的结果for x in nums2:       #遍历列表2while len(st) and st[-1] < x:     #这个存在意义就是将前一个小一点的数和后一个大一点的数组成字典，如果后一个数比前一个小就不组成字典。d[st.pop()] = xst.append(x)for x in nums1:ans.append(d.get(x, -1))   #字典(Dictionary) get() 函数返回指定键的值，如果值不在字典中返回默认值。组成字典。return ans

346.Moving Average fromData Stream 从数据流中移动平均值（Easy）

Given a stream of integers and a window size, calculate the moving average of all integers in the sliding window.

For example,
MovingAverage m = new MovingAverage(3);
m.next(1) = 1
m.next(10) = (1 + 10) / 2
m.next(3) = (1 + 10 + 3) / 3
m.next(5) = (10 + 3 + 5) / 3

给一个整数流和一个窗口，计算在给定大小的窗口里的数字的平均值。

解法：队列queue，用一个queue记录进入窗口的整数。当流进窗口的整数不足时，计算所有窗口内的数字和返回，当进入窗口的整数多于窗口大小时，移除最先进入窗口的整数，新的整数进入queue，然后计算窗口内的整数和。

# Time:  O(1)
# Space: O(w)
from collections import dequeclass MovingAverage(object):def __init__(self, size):"""Initialize your data structure here.:type size: int"""self.__size = sizeself.__sum = 0self.__q = deque([])def next(self, val):""":type val: int:rtype: float"""if len(self.__q) == self.__size:self.__sum -= self.__q.popleft()self.__sum += valself.__q.append(val)return 1.0 * self.__sum / len(self.__q)# Your MovingAverage object will be instantiated and called as such:
# obj = MovingAverage(size)
# param_1 = obj.next(val)　

933. Number of Recent Calls  最近的通话数 （Easy）

Write a class RecentCounter to count recent requests.

It has only one method: ping(int t), where t represents some time in milliseconds.

Return the number of pings that have been made from 3000 milliseconds ago until now.

Any ping with time in [t - 3000, t] will count, including the current ping.

It is guaranteed that every call to ping uses a strictly larger value of t than before.

Example 1:

Input: inputs = ["RecentCounter","ping","ping","ping","ping"], inputs = [[],[1],[100],[3001],[3002]]
Output: [null,1,2,3,3]

Note:

  1. Each test case will have at most 10000 calls to ping.
  2. Each test case will call ping with strictly increasing values of t.
  3. Each call to ping will have 1 <= t <= 10^9.

使用一个队列，当t时间到达之后，在t-3000之前的调用全部删除，因为这些不会对后面的产生任何影响了。删除之后，求长度就好了。

class RecentCounter(object):def __init__(self):self.que = collections.deque()def ping(self, t):""":type t: int:rtype: int"""while self.que and self.que[0] < t - 3000:self.que.popleft()self.que.append(t)return len(self.que)# Your RecentCounter object will be instantiated and called as such:
# obj = RecentCounter()
# param_1 = obj.ping(t)

103. Binary Tree Zigzag Level Order Traversal  二叉树之字形层序遍历 （Medium）

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3/ \9  20/  \15   7

return its zigzag level order traversal as:

[[3],[20,9],[15,7]
]

102题的变形，不同之处在于一行是从左到右遍历，下一行是从右往左遍历，交叉往返的之字形的层序遍历。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution(object):def zigzagLevelOrder(self, root):""":type root: TreeNode:rtype: List[List[int]]"""if root is None:    #如果根节点为空，则返回一个空列表return []result, current, level = [], [root], 1             while current:      #根不为空就一直循环next_level, vals = [], []     for node in current:vals.append(node.val)if node.left:next_level.append(node.left)if node.right:next_level.append(node.right)if level % 2:result.append(vals)else:result.append(vals[::-1])level += 1current = next_levelreturn result

331. Verify Preorder Serialization of a Binary Tree  验证二叉树的前序序列  （Meidum）

One way to serialize a binary tree is to use pre-order traversal. When we encounter a non-null node, we record the node's value. If it is a null node, we record using a sentinel value such as #.

     _9_/   \3     2/ \   / \4   1  #  6
/ \ / \   / \
# # # #   # #

For example, the above binary tree can be serialized to the string "9,3,4,#,#,1,#,#,2,#,6,#,#", where # represents a null node.

Given a string of comma separated values, verify whether it is a correct preorder traversal serialization of a binary tree. Find an algorithm without reconstructing the tree.

Each comma separated value in the string must be either an integer or a character '#'representing null pointer.

You may assume that the input format is always valid, for example it could never contain two consecutive commas such as "1,,3".

Example 1:

Input: 
"9,3,4,#,#,1,#,#,2,#,6,#,#"
Output:

true

Example 2:

Input: 
"1,#"
Output:

false

Example 3:

Input: 
"9,#,#,1"
Output:

false

给了一个先序遍历，判断能不能构成合法的二叉树。这个字符串中，#表示空节点。

判断一个二叉树是否合法的情况，那么应该是个递归或者循环问题。那么解决问题的思路是从顶部向下分析还是从底下向顶部分析呢？正确的结果应该是从二叉树的底部向上进行分析，因为我们可以通过#号判断是否是空节点，然后判断最底下的叶子节点是否含有两个空孩子的方式，循环向上解决这个问题。

所以这个题的思路就很明了了：用一个栈，从字符串的左侧向右依次进栈，如果满足栈的后三位是数字，#，#的模式时，说明可以构成合法的叶子节点，把这个叶子节点换成#号，代表空节点，然后继续遍历。最后应该只剩下一个#，那么就是一个合法的二叉树。

如：”9,3,4,#,#,1,#,#,2,#,6,#,#” 遇到x # #的时候，就把它变为 #

模拟一遍过程：

9,3,4,#,# => 9,3,# 继续读
9,3,#,1,#,# => 9,3,#,# => 9,# 继续读
9,#2,#,6,#,# => 9,#,2,#,# => 9,#,# => #

原文：https://blog.csdn.net/fuxuemingzhu/article/details/79537797

class Solution(object):def isValidSerialization(self, preorder):""":type preorder: str:rtype: bool"""stack = []for node in preorder.split(','):       #将这个字符串以逗号作为区分，每一个点循环一次stack.append(node)       #将这个点加入栈中while len(stack) >= 3 and stack[-1] == stack[-2] == '#' and stack[-3] != '#':        #当这个栈的长度大于等于3且栈的最后一位和倒数第二位是井号，倒数第三位是数字stack.pop(), stack.pop(), stack.pop()        #就将这三个数字取出删除stack.append('#')      #将井号压入栈中return len(stack) == 1 and stack.pop() == '#'    #如果栈的长度为1且将最后一个字符取出为井号，则说明为真

946. Validate Stack Sequences  验证栈序列  （Medium）

Given two sequences pushed and popped with distinct values, return true if and only if this could have been the result of a sequence of push and pop operations on an initially empty stack.

Example 1:

Input: pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
Output: true
Explanation: We might do the following sequence:
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1

Example 2:

Input: pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
Output: false
Explanation: 1 cannot be popped before 2.

Note:

  1. 0 <= pushed.length == popped.length <= 1000
  2. 0 <= pushed[i], popped[i] < 1000
  3. pushed is a permutation of popped.
  4. pushed and popped have distinct values.

给出了一个栈的输入数字，按照这个顺序输入到栈里，能不能得到一个对应的栈的输出序列。

我使用的方法异常简单粗暴，直接模拟这个过程。

题目已知所有的数字都是不同的。我们在模拟这个弹出的过程中，进行一个判断，如果这个弹出的数字和栈顶数字是吻合的，那么栈就要把已有的数字弹出来。如果栈是空的，或者栈顶数字和弹出的数字不等，那么我们应该把pushed数字一直往里放，直到相等为止。

最后，如果栈的入栈序列能得到这个出栈序列，那么栈应该是空的。
原文：https://blog.csdn.net/fuxuemingzhu/article/details/84495797

class Solution(object):def validateStackSequences(self, pushed, popped):""":type pushed: List[int]:type popped: List[int]:rtype: bool"""stack = []      #建立一个空栈N = len(pushed)    pi = 0for i in range(N):if stack and popped[i] == stack[-1]:     #如果栈为真且要删除的第一个元素和栈顶元素相等，就将栈中元素删除stack.pop()else:     #否则while pi < N and pushed[pi] != popped[i]:stack.append(pushed[pi])pi += 1pi += 1return not stack

310. Minimum Height Trees  最小高度树 （Medium）

For an undirected graph with tree characteristics, we can choose any node as the root. The result graph is then a rooted tree. Among all possible rooted trees, those with minimum height are called minimum height trees (MHTs). Given such a graph, write a function to find all the MHTs and return a list of their root labels.

Format
The graph contains n nodes which are labeled from 0 to n - 1. You will be given the number n and a list of undirected edges (each edge is a pair of labels).

You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.

Example 1 :

Input:
n = 4
,
edges = [[1, 0], [1, 2], [1, 3]]
0|1/ \2   3 Output:
[1]

Example 2 :

Input:
n = 6
,
edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]
0  1  2\ | /3|4|5 Output:
[3, 4]

Note:

  • According to the definition of tree on Wikipedia: “a tree is an undirected graph in which any two vertices are connected by exactly one path. In other words, any connected graph without simple cycles is a tree.”
  • The height of a rooted tree is the number of edges on the longest downward path between the root and a leaf.
class Solution(object):def findMinHeightTrees(self, n, edges):""":type n: int:type edges: List[List[int]]:rtype: List[int]"""if n == 1:return [0]neighbors = collections.defaultdict(set)for u, v in edges:neighbors[u].add(v)neighbors[v].add(u)pre_level, unvisited = [], set()for i in xrange(n):if len(neighbors[i]) == 1:  # A leaf.pre_level.append(i)unvisited.add(i)# A graph can have 2 MHTs at most.# BFS from the leaves until the number# of the unvisited nodes is less than 3.while len(unvisited) > 2:cur_level = []for u in pre_level:unvisited.remove(u)for v in neighbors[u]:if v in unvisited:neighbors[v].remove(u)if len(neighbors[v]) == 1:cur_level.append(v)pre_level = cur_levelreturn list(unvisited)

279. Perfect Squares 完美平方  （Medium）

Given a positive integer n, find the least number of perfect square numbers (for example, 1, 4, 9, 16, ...) which sum to n.

Example 1:

Input: n =
12
Output: 3
Explanation:

12 = 4 + 4 + 4.

Example 2:

Input: n =
13
Output: 2
Explanation:

13 = 4 + 9.

class Solution(object):def numSquares(self, n):""":type n: int:rtype: int"""if n < 2:return nlst = []i = 1while i * i <= n:lst.append( i * i )i += 1cnt = 0toCheck = {n}while toCheck:cnt += 1temp = set()for x in toCheck:for y in lst:if x == y:return cntif x < y:breaktemp.add(x-y)toCheck = tempreturn cnt

[LeetCode]-Python刷题第三周(栈和队列）相关推荐

  1. DICTATOR第三周栈与队列作业

    链表栈与队列 C语言实现 !!!本代码学习参考部分较多,仅供提交作业及课内交流使用,并无任何借鉴价值. 链表栈 //Author DICTATOR //This is Stack Code#inclu ...

  2. 【Leetcode】 刷题之路1（python）

    leetcode 刷题之路1(python) 看到有大佬总结了一些相关题目,想着先刷一类. 1.两数之和 15.三数之和 16.最接近的三数之和 11.盛最多的水 18.四数之和 454.四数相加II ...

  3. leetcode刷题（三）——容斥原理

    leetcode刷题系列三.这一节的内容主要是容斥原理的题目和题解. 百度百科上容斥原理的解释: 在计数时,必须注意没有重复,没有遗漏.为了使重叠部分不被重复计算,人们研究出一种新的计数方法,这种方法 ...

  4. leetcode分类刷题笔记

    leetcode分类刷题笔记--基于python3 写在前面 1.做题如果实在想不出时间复杂度比较优的解法,可以先写出暴力解法,尝试在其基础上优化 2.排序.双指针.二分等--经常可以优化时间复杂度 ...

  5. .net 遍历数组找重复值写入一个新数组_第二轮 Python 刷题笔记一：数组

    经过四十多天缓慢的刷题,现在进度大概是刷了八十多道 LeetCode 题,最近也在吸取过来人的经验,仍然需要对刷题计划进行调整. 首先明确一下目标,我是有些 Python 基础,想通过刷题掌握更多算法 ...

  6. 【Python刷题篇】Python从0到入门3|循环、条件复习、元组入门、字典入门

    Python从0到入门3目录 前言 Q1:团队分组 Q2:禁止重复注册 Q3:元组-牛客运动会 Q4:字典-遍历字典 Q5:字典-毕业生就业调查 Q6:姓名与学号 总结 前言 - 本期是Python从 ...

  7. Python 刷题常用语法与数据结构汇总-2022.01.30

    [笔试]python刷题笔记(基础)! https://blog.csdn.net/a_123456598/article/details/105420802 python语法刷题 https://b ...

  8. LeetCode代码刷题（17~24）

    目录 17. 电话号码的字母组合 18. 四数之和 19. 删除链表的倒数第 N 个结点 20. 有效的括号 21. 合并两个有序链表 22. 括号生成 23. 合并K个升序链表 24. 两两交换链表 ...

  9. python刷题 NOI题库 python题解 洛谷、牛客网、AcWing 刷题等

    NOI题库 python题解-2022.01.07整理(1.1-1.3) NOI题库 python题解-2022.01.07整理(1.1-1.3)_dllglvzhenfeng的博客-CSDN博客 N ...

最新文章

  1. 用TCP/IP进行网际互联一
  2. [UE4]使用蓝图关闭对象的碰撞SetActorEnableCollision
  3. librtmp实时消息传输协议(RTMP)库代码浅析
  4. 全国计算机等级考试题库二级C操作题100套（第73套）
  5. Linux文件属性之r、w、x
  6. linux svn cleanup 用法,SVN命令之清理命令（clean up）的功能及使用技巧
  7. STL10-deque容器
  8. hdu 4775 Infinite Go(暴力)
  9. Android反射修改view,Android 修改viewpage滑动速度的实现代码
  10. rabbitmq 发送的用户名是什么
  11. t-SNE 高维数据可视化
  12. HDMI调试基本原理
  13. 网站分析实战总结（一）
  14. 点电荷分布matlab仿真,利用Matlab模拟点电荷的电场分布..doc
  15. 迅为STM32MP157开发板手册更新记录
  16. 结构与算法 7-32 哥尼斯堡的“七桥问题” (25 分)
  17. 基于jsp的消防知识宣传网站ssh框架
  18. 移动应用安全开发要求（1，源码安全）
  19. Landsat系列卫星：Landsat 9 详解和细节（NASA/USGS）
  20. echarts图表没有数据的时候，在页面显示暂无数据

热门文章

  1. 2022“杭电杯”中国大学生算法设计超级联赛（8）题解报告
  2. 商务礼仪——尊重、适合、适合的尊重
  3. 测试服务器角色转移系统,王者荣耀转区测试什么时候开始 跨系统角色转移测试时间...
  4. android如何播放动画,Android中播放Gif动画取巧的办法
  5. 2022东南大学916复试时间轴
  6. Query查询(SQ01/SQ02/SQ03)分配事务代码（T-CODE）
  7. 使GridView内容不换行
  8. 277、H3C无线组网内部培训培训资料
  9. NYOJ---1131买水果
  10. 一种日志采集装置及方法