一、题目
You are climbing a stair case. It takes n steps to reach to the top.
Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
Note: Given n will be a positive integer.
Example 1:
Input: 2 Output: 2 Explanation: There are two ways to climb to the top. 1. 1 step + 1 step 2. 2 steps
Example 2:
Input: 3 Output: 3 Explanation: There are three ways to climb to the top. 1. 1 step + 1 step + 1 step 2. 1 step + 2 steps 3. 2 steps + 1 step
爬楼梯，每次只能爬一步或者两步，看一共有多少爬法。
二、思路
首先肯定能用递归来计算，到达第 i 个位置时，都有两种选择，爬一步（此时可以表示成 i - 1 位置上然后上一步），或者爬两步（此时可以看成 i - 2 位置然后跨两步），所以此问题到达第 i 个位置可能
的结果可以表示成第 i - 1 位置上的结果 + i - 2 位置上的结果。跟斐波那契数列一样。所以代码可以这样写：
def climbStairs2(n):
if n == 1:
return 1
elif n == 2:
return 2
else:
print(climbStairs2(n-1)+climbStairs2(n-2))
return climbStairs2(n-1)+climbStairs2(n-2)
但是递归一般是像我这样的菜鸡才用的，高手一般都不用递归，有点慢，会重复计算很多之前计算过的步骤。于是我花了点时间学习了动态规划，其实我感觉相比较递归，动态规划就是把递归过程中的子问题的解
集用一个数组保存下来，以备后用，整体上我感觉跟递归的差距就在这里了，同样也是把一个大问题分成好多小问题，然后解决每一个小问题的最优解，最后汇集。这是我的观点，由于接触时间比较短，有说错的
地方还请大神提点。
动态规划的代码如下，用三个变量保存结果：
def climbStairs(n):
"""
:type n: int
:rtype: int
"""
n_1 = 1
n_2 = 0
for i in range(1,n+1):
tmp = n_1+n_2
n_2 = n_1
n_1 = tmp
print(tmp)
return tmp
学习动态规划的一些例子和代码如下：
#coding:utf-8
import numpy as np
def climbStairs(n):
"""
:type n: int
:rtype: int
"""
n_1 = 1
n_2 = 0
for i in range(1,n+1):
tmp = n_1+n_2
n_2 = n_1
n_1 = tmp
print(tmp)
return tmp
"""
给定一个数组，每次取出来的必须不相邻，求出能取出来的数加起来最大
"""
#1递归做法
def rec_opt(arr,i):
if i == 0:
return arr[0]
elif i ==1:
return max(arr[0],arr[1])
else:
A = rec_opt(arr,i-2)+arr[i]
B = rec_opt(arr,i-1)
print(max(A,B))
return max(A,B)
#2、非递归做法
def dp_opt(arr):
opt = np.zeros(len(arr))
opt[0] = arr[0]
opt[1] = max(arr[0],arr[1])
for i in range(2,len(arr)):
A = opt[i-2]+arr[i]
B = opt[i-1]
opt[i] = max(A,B)
print(opt[len(arr)-1])
return opt[len(arr)-1]
"""
arr={3,34,4,12,5,2} S = 9,均为正整数
如果arr中存在数据加起来等于S，就返回true，否则flase
对于每个数都有两种可能，选或者不选
"""
#1、递归做法
def rec_subset(arr,i,s):
if s == 0:
return True
elif i == 0:
return arr[0] == s
elif arr[i] > s:
return rec_subset(arr,i-1,s)
else:
A = rec_subset(arr,i-1,s-arr[i])
B = rec_subset(arr,i,s-arr[i])
print(A or B)
return A or B
#2、非递归其实就是用数组保存重叠的子问题
def dp_subset(arr,S):
subset = np.zeros((len(arr),S+1),dtype=bool)
subset[:,0] = True
subset[0,:] = False
subset[0,arr[0]] = True
for i in range(1,len(arr)):
for s in range(1,S+1):
if arr[i] > s:
subset[i,s] = subset[i-1,s]
else:
A = subset[i-1,S-arr[i]]
B = subset[i-1,s]
subset[i,s] = A or B
r,c = subset.shape
print(subset[r-1,c-1])
return subset[r-1,c-1]
def climbStairs2(n):
if n == 1:
return 1
elif n == 2:
return 2
else:
#print(climbStairs2(n-1)+climbStairs2(n-2))
return climbStairs2(n-1)+climbStairs2(n-2)
if __name__ == '__main__':
#climbStairs2(4)
climbStairs(4)
arr = [1,2,4,1,7,8,3]
arr1 = [4,1,1,9,1]
arr2 = [3,34,4,12,5,2]
#rec_opt(arr,6) #出现很多重叠子问题，采用递归会很慢
#dp_opt(arr)
#rec_subset(arr2,len(arr2)-1,9)
#dp_subset(arr2,12)