力扣刷题 day11：09-10

1.判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

 方法一：逐个遍历，找出是否含有对应的字母

#方法一：逐个遍历，找出是否含有对应的字母
def isSubsequence(s,t):
    if len(s)==0:    #特殊情况单独判断
        return True
    left=0
    for r in range(len(t)):
        if s[left]==t[r]:
            left+=1          #判断是否有对应的字母
            if left==len(s):
                return True
    return False

方法二：双指针法

#方法二：双指针法
def isSubsequence(s,t):
    p1=0   #指向s
    p2=0   #指向t
    while p1<len(s) and p2<len(t):
        if s[p1]==t[p2]:
            p1+=1     #相等则右移继续判断下一位
        p2+=1         #相不相等都要移动继续判断
    return p1==len(s)  #判断是否移动到了最后一位

方法三：动态规划

#方法三：动态规划
def isSubsequence(s,t):
    m=len(s)
    n=len(t)
    dp=[[False]*(m+1) for i in range(n+1)]     #dp[i][j]长度为i，j，的字符串s，t，前者是否是后者的子序列
    for i in range(n+1):
        dp[0][i]=True          #dp[0][i]一定为true
    for i in range(1,m+1):
        for j in range(1,n+1):
            if s[i-1]==t[j-1]:
                dp[i][j]=dp[i-1][j-1] #状态转移方程
            else:
                dp[i][j]=dp[i][j-1]
    return dp[m][n]

2.斐波那契数

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

方法一:直接利用关系后一天等于前两天之和 

#方法一:直接利用关系后一天等于前两天之和
def fib(n):
    if n==0:
        return 0
    a,b=1,1
    for i in range(n-1):
        a,b=b,a+b
    return a

方法二：递归(f(n)=f(n-1)+f(n-2)) 

#方法二：递归(f(n)=f(n-1)+f(n-2))
def fib(n):
    if n == 0:
        return 0
    if n==1 :
        return 1
    return fib(n-1)+fib(n-2)

3.使用最小花费爬楼梯

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

方法一：动态规划 

#方法一：动态规划
def minCostClimbingStairs(cost):
    dp=[0]*(len(cost))
    dp[0]=cost[0]
    dp[1]=cost[1]
    for i in range(2,len(cost)):      #dp[i]表示爬到第i层楼的最小花费
        dp[i]=min(dp[i-1],dp[i-2])+cost[i]        #状态转移方程
    return min(dp[len(cost) -1],dp[len(cost) -2])        #爬到楼顶的等于前一阶或者前两阶的最小花费

优化，用两个变量储存数据 

#优化，用两个变量储存数据
def minCostClimbingStairs(cost):
    f1=cost[0]
    f2=cost[1]
    for i in range(2,len(cost)):
        t=min(f1,f2)+cost[i]
        f1=f2
        f2=t
    return min(f1,f2)