1、栈
逆波兰表达式求值
根据逆波兰表示法，求表达式的值。
有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
说明：
整数除法只保留整数部分。
给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1：
输入: ["2", "1", "+", "3", "*"]
输出: 9
解释: ((2 + 1) * 3) = 9
示例 2：
输入: ["4", "13", "5", "/", "+"]
输出: 6
解释: (4 + (13 / 5)) = 6
示例 3：
输入: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
输出: 22
解释:
((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
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/evaluate-reverse-polish-notation
class Solution(object):
def evalRPN(self, tokens):
"""
用到栈(先进后出的数据结构)
遍历表达式:
碰到数字则入栈
碰到运算符则连续从栈中取出2个元素, 使用该运算符运算然后将结果入栈
最后栈中剩余一个数字, 就是结果.
"""
result = []
for i in tokens:
if i not in (‘+‘, ‘-‘, ‘*‘, ‘/‘):
result.append(int(i))
else:
num1 = result.pop()
num2 = result.pop()
if i == ‘+‘:
result.append(num2 + num1)
elif i == ‘-‘:
result.append(num2 - num1)
elif i == ‘*‘:
result.append(num2 * num1)
else:
result.append(int(num2 * 1.0 / num1))
return result[0]
2、队列
最近的请求次数
写一个 RecentCounter 类来计算最近的请求。
它只有一个方法：ping(int t)，其中 t 代表以毫秒为单位的某个时间。
返回从 3000 毫秒前到现在的 ping 数。
任何处于 [t - 3000, t] 时间范围之内的 ping 都将会被计算在内，包括当前（指 t 时刻）的 ping。
保证每次对 ping 的调用都使用比之前更大的 t 值。
示例：
输入：inputs = ["RecentCounter","ping","ping","ping","ping"], inputs = [[],[1],[100],[3001],[3002]]
输出：[null,1,2,3,3]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-recent-calls
class RecentCounter(object):
def __init__(self):
self.nums = []
self.size = 0
def ping(self, t):
"""
:type t: int
:rtype: int
"""
self.nums.append(t)
self.size += 1
while self.size and self.nums[0] < t - 3000 :
del self.nums[0]
self.size -= 1
return self.size
3、动态规划
砖墙
你的面前有一堵方形的、由多行砖块组成的砖墙。 这些砖块高度相同但是宽度不同。你现在要画一条自顶向下的、穿过最少砖块的垂线。
砖墙由行的列表表示。 每一行都是一个代表从左至右每块砖的宽度的整数列表。
如果你画的线只是从砖块的边缘经过，就不算穿过这块砖。你需要找出怎样画才能使这条线穿过的砖块数量最少，并且返回穿过的砖块数量。
你不能沿着墙的两个垂直边缘之一画线，这样显然是没有穿过一块砖的。
示例：
输入: [[1,2,2,1],
[3,1,2],
[1,3,2],
[2,4],
[3,1,2],
[1,3,1,1]]
输出: 2
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/brick-wall
class Solution(object):
def minPathSum(self, grid):
"""
:type grid: List[List[int]]
:rtype: int
"""
if not grid:
return -1
m, n = len(grid), len(grid[0])
f = [[0]*n for _ in range(m)]
for i in range(m-1, -1, -1):
for j in range(n-1, -1, -1):
if i != m-1 and j != n-1:
f[i][j] = min(f[i][j + 1], f[i + 1][j]) + grid[i][j]
elif i == m-1 and j != n-1:
f[i][j] = f[i][j + 1] + grid[i][j]
elif i != m - 1 and j == n - 1:
f[i][j] = f[i + 1][j] + grid[i][j]
else:
f[i][j] = grid[i][j]
return f[0][0]
4、贪心算法
跳跃游戏
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4]
输出: true
解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2:
输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/jump-game
方法一：DFS
class Solution(object):
def canJump(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
def dfs(index, nums, sets, n):
if index in sets:
return False
if index >= n - 1:
return True
for j in range(min(nums[index], n - index - 1), 0, -1):
if dfs(index + j, nums, sets, n):
return True
sets.add(index)
return False
return dfs(0, nums, set(), len(nums))
方法二：贪心
class Solution(object):
def canJump(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
if not nums:
return False
last = 0
n = len(nums)
for i, step in enumerate(nums):
if i <= last <= i + step:
last = i + step
if last >= n - 1:
return True
return False
原文地址：https://www.cnblogs.com/rnanprince/p/12188057.html