python-leetcode刷题日记

1、defaultdict  用于计数，计算元素key出现的个数,可以避免key不存在的时候报错，当KEY不存在的时候默认为0，可以是list、set、str 
defaultdict[key].append[value]

49. 字母异位词分组
​
给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
​
字母异位词 是由重新排列源单词的所有字母得到的一个新单词。
​
思路：得到新单词排序后的数据应该是一致的，将每个字符串排序，并将排序后一致的数据放在一块

class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        res = {}
        m = defaultdict(list)
        for i in strs:
            m[''.join(sorted(i))].append(i)
        return  list(m.values())

122. 买卖股票的最佳时机 II
​
给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。
思路：计算一段一段的时间可以获取最大的利益数，意思就是在下一个数据小于上一个数据的时候，此段数据就结束，并计算此段数据的盈利情况。以及累计并相加

# 进阶版
def maxProfit1(self, prices):
    """
    :type prices: List[int]
    :rtype: int
    """
    temp = prices[0]
    res = 0
    buy = prices[0]     # 用于临时记录一个段的第一个
    for i in range(len(prices)):   
        if prices[i]<temp:
            k = temp-buy   # 计算当前一小段的数据
            res+=k      # 将当前段的数据相加
            buy=prices[i]    # 将第一个移动到第二段
        temp = prices[i]
        if temp>buy and i==len(prices)-1:
            res += temp-buy
    return  res

13. 罗马数字转整数
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
​
字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
​
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
​
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。
​
思路：
将数据依次遍历，大于后面的数据就加上当前的数据，小于后面的数据的时候就减去当前的数据

class Solution(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """   
        lis = list(s)
        res = 0
        infectValues = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
        one = 0
        if len(lis)==1:
            return infectValues.get(lis[0])
        i = 0
        while i < len(s)-1:
            if infectValues[lis[i]]<infectValues[lis[i+1]]: # 小于后面的数据，减去当前的数据
                one -=infectValues[lis[i]] #减去
                i+=1
            elif infectValues[lis[i]]>=infectValues[lis[i+1]]: # 大于或等于后面的数据，加上当前的数据
                one += infectValues[lis[i]]
                i+=1
        one += infectValues[lis[len(lis)-1]] #加上最后一个数据
        return one
​

2606. 找到最大开销的子字符串

给你一个字符串 s ，一个字符 互不相同 的字符串 chars 和一个长度与 chars 相同的整数数组 vals 。
​
子字符串的开销 是一个子字符串中所有字符对应价值之和。空字符串的开销是 0 。
​
字符的价值 定义如下：
​
如果字符不在字符串 chars 中，那么它的价值是它在字母表中的位置（下标从 1 开始）。
比方说，'a' 的价值为 1 ，'b' 的价值为 2 ，以此类推，'z' 的价值为 26 。
否则，如果这个字符在 chars 中的位置为 i ，那么它的价值就是 vals[i] 。
请你返回字符串 s 的所有子字符串中的最大开销。

解题思路：

python动态规划，转换为计算当前数组最大的子数组。首先是把转换为数组，然后计算数组的最大值的问题。是否加前面的数据取决于前面的数据是否大于0，如果大于0，那么加上前面的数据可以会更大，从而计算出数组最大的子数组

class Solution(object):
    def maximumCostSubstring(self, s, chars, vals):
        """
        :type s: str
        :type chars: str
        :type vals: List[int]
        :rtype: int
        """
        resList = []   // 用于存放替换后的字符串
        charList = [i for i in chars]
        for i in s:
            if i in charList:
                m = charList.index(i)
                resList.append(vals[m])
            else:
                num = ord(i)-96
                resList.append(num)
        print(resList)
        res = [i*0 for i in range(len(resList))]   //用于存放第I个数据的最大
        res[0] = resList[0]
        s = resList[0]
        for i in range(1,len(resList)):
            res[i] = max(res[i-1],0)+resList[i]   //递推公式
        if max(res)<0:
            return 0 
        return max(res)