剑指OFFER DAY10

第 10 天

动态规划 Dynamic programming   记忆化搜索 Memory Search

---

剑指 Offer 46. 把数字翻译成字符串 

这道题和斐波那契数列的题一样，只不过多了一个判断条件

递推公式：

if 最后两个数>25 or 最后两个数<10:

        out(n) = out(n-1)

else:

        out(n) = out(n-1) + out(n-2)

这里解释一下，当最后两个数大于25时它不能构成一个字母，只能由除了最后一个数字以外所有的可能+最后一个数字构成；当最后两个数小于10时，他为0X，0已经是一个字母了，0X的值等于X，所以和刚才的情况一样。

当最后两个数小于等于25，大于等于10时，这两个数可以拆开看也可以合起来看，有两种可能，拆开看是out(n-1)，合起来看是out(n-2)。

class Solution:
    def translateNum(self, num: int) -> int:
        string = str(num)
        n = len(string)
        if n == 1:
            return 1
        if n == 2:
            if num<=25:
                return 2
            return 1

        index = 2
        b = 1
        if int(string[0:index])<=25:
            a = 2
        else:
            a = 1

        index = 3

        while index <= n:
            if int(string[index-2:index])>25  or int(string[index-2:index])<10:
                a = a
                b = a
            else:
                tem = a
                a += b
                b = tem
            index += 1

        return a
        

---

剑指 Offer 48. 最长不含重复字符的子字符串

 本题为最长子序列的题不过稍微做了一点更改，思路如下

设置keys = [],记录到目前为止没有重复的最长子串，先将第一个字符加入keys；并且设置length为keys的长度。从第二个字符开始搜索，如果遇到不充分字符，加入keys；遇到重复字符，将keys在重复字符处截断取后半部分。设置max参数用于实施记录length最大值。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if s is "": return 0
        n = len(s)
        max_length = 1
        keys = [s[0]]
        for i in range(1,n):
            for j in range(len(keys)):
                if s[i] == keys[j]:
                    keys = keys[j+1:]
                    break
            keys.append(s[i])
            length = len(keys)
            if max_length < length:
                max_length = length
        return max_length

 大佬借助动态规划+哈希表可以将空间复杂的降低到O(n)  

 

 代码如下

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        dic = {}
        res = tmp = 0
        for j in range(len(s)):
            i = dic.get(s[j], -1) # 获取索引 i
            dic[s[j]] = j # 更新哈希表
            tmp = tmp + 1 if tmp < j - i else j - i # dp[j - 1] -> dp[j]
            res = max(res, tmp) # max(dp[j - 1], dp[j])
        return res