力扣题解 ———每日一题+11-14题

每日一题

# 2586. 统计范围内的元音字符串数
# 给你一个下标从 0 开始的字符串数组 words 和两个整数：left 和 right 。
#
# 如果字符串以元音字母开头并以元音字母结尾，那么该字符串就是一个 元音字符串 ，其中元音字母是 'a'、'e'、'i'、'o'、'u' 。
#
# 返回 words[i] 是元音字符串的数目，其中 i 在闭区间 [left, right] 内

题解：此题较为简单，之间创建一个元音表，遍历串的首尾判断是否属于即可

class Solution(object):
    def vowelStrings(self, words, left, right):
        """
        :type words: List[str]
        :type left: int
        :type right: int
        :rtype: int
        """
        yuan=['a','e','i','o','u']
        count=0
        s=""
        while words!=None:
            for i in range(left,right+1):
                s=words[i]
                if s[0]in yuan and s[len(s)-1]in yuan:
                    count+=1
                s=""
            return count

11. 盛最多水的容器
给定一个长度为 n 的整数数组 height 。
有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
说明：你不能倾斜容器。

题解：可用暴力解处理，即俩俩组合，选取较小的一边为宽计算面积即可，最后取所有结果的求最大值

优化：折半思维，双指针优化，从头尾同时开始查找，减少了大量的重复操作，其他原理一致

class Solution(object):
    def maxArea(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        # # 暴力解
        # max_water=0
        # for i in range(len(height)):
        #     for j in range(i+1,len(height)):
        #         a=(min(height[i],height[j])* abs(i-j))
        #         if a>max_water:
        #             max_water=a
        # return max_water
        # 优化双指针
        max_water=0
        right =len(height)-1
        left=0
        while left<right:
            max_water=max(max_water,\
                          min(height[left],height[right])\
                          *abs(right-left))
            if height[left] < height[right]:
                left += 1
            else:
                right -= 1
            return max_water

12.

12. 整数转罗马数字
罗马数字包含以下七种字符： 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。
给你一个整数，将其转为罗马数字。
示例 1:
输入: num = 3
输出: "III"
示例 2:
输入: num = 4
输出: "IV"
示例 3:
输入: num = 9
输出: "IX"
示例 4:
输入: num = 58
输出: "LVIII"
解释: L = 50, V = 5, III = 3.
示例 5:
输入: num = 1994
输出: "MCMXCIV"
解释: M = 1000, CM = 900, XC = 90, IV = 4.

题解：这个题第一次看到有点懵逼，第一想法就是建立字典然后采用映射关系，后面越写越发现，只要你字典够全面（不是把所有数字都写完昂，是关于罗马数字左右不同的情况），就可以很容易解决  对比数字，需要注意这与平时处理求出每位数字不同，这里罗马数字已经就代不同数字，所以采用减法逐步匹配字典

class Solution(object):
    def intToRoman(self, num):
        """
        :type num: int
        :rtype: str
        """
        # 字典解法
        values=[1000,900,500,400,100,90,50,40,10,9,5,4,1]
        numerals=['M','CM','D','CD','C','XC',
                  'L','XL','X','IX','V','IV','I']
        result=''
        for i in range(0,len(values)):
            while num >=values[i]:
                num-=values[i]
                result+=numerals[i]
        return result

13.数字转罗马

题解：与12题基本大同小异，但是需要注意，罗马数字为串存储，匹配时一个一个取出匹配，这就涉及到罗马数字中某些字母位于左右不同的值得情况

举例：       mcm
            1.num=0+m
            2.num=0+m+c
            3.num=0+m+c+m 此时发生错误
            应该为num=0+m+c+m-c-c
            本是1000+900 但是逐位扫会把原本用来组成900的c多加一次，故要减去一次

class Solution(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """
        dict1={}
        num=0
        values=[1000,900,500,400,100,90,50,40,10,9,5,4,1]
        numerals=['M','CM','D','CD','C','XC',
                  'L','XL','X','IX','V','IV','I']
        for i in range(len(values)):
            dict1[numerals[i]] = values[i]
        for i in range(len(s)):
            # 判断连体词 当前位大于后一位
            """
            mcm
            1.num=0+m
            2.num=0+m+c
            3.num=0+m+c+m 此时发生错误
            m>c
            num=0+m+c+m-c-c
            本是1000+900 但是逐位扫会把原本用来组成900的c多加一次，故要减去一次
            """
            if i > 0 and dict1[s[i]] > dict1[s[i - 1]]:
                num += dict1[s[i]] - 2 * dict1[s[i - 1]]
            else:
                num += dict1[s[i]]
        return num

14. 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1：
输入strs = ["flower","flow","flight"]
输出："fl"
示例 2：
输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。

题解：关注类型  输入为一个嵌套串的表，俩种方法

1.可模仿每日一题那种形式先将单独的串取出，然后进行操作，在此题较为繁琐

2.直接使用二维查看第一个索引为串在表中位置，第一个索引为字符在串中的位置

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        # 嵌套形式可二维查看
        if not strs:  # 空串检测
            return ""
        
        for i in range(len(strs[0])):  # 选取一个串作为标准，用其字符进行检查
            for j in range(1,len(strs)):  # 在剩余串中查找
                if i >= len(strs[j]) or strs[j][i]!=strs[0][i]: # 如果某个字母不一致则返回此时的基准
                    return strs[0][:i]

        return strs[0]  # 如果首字符为""则直接返回