LeetCode腾讯精选50题---11,14,15

Day03

11. 盛最多水的容器 (Medium)

11. 盛最多水的容器 (Medium)
思路：双指针

图11_container_with_most_water.png

"""
    给你n个非负整数a1，a2，...，an，每个数代表坐标中的一个点(i,ai) 。在坐标内画n条垂直线，垂直线i的两个端点分别为(i,ai) 和 (i, 0) 。
    找出其中的两条线，使得它们与x轴共同构成的容器可以容纳最多的水。

    说明：你不能倾斜容器。
    见图11_container_with_most_water.png

    示例 1：
    输入：[1,8,6,2,5,4,8,3,7]
    输出：49
    解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为49。

    示例 2：
    输入：height = [1,1]
    输出：1

    示例 3：
    输入：height = [4,3,2,1,4]
    输出：16

    示例 4：
    输入：height = [1,2,1]
    输出：2

    提示：
    n = height.length
    2 <= n <= 3 * 104
    0 <= height[i] <= 3 * 104
"""
from typing import List


class Solution_Double_Point(object):
    # 双指针
    # Time complexity: O(N)
    # Space complexity: O(1)
    def maxArea(self, height: List[int]) -> int:
        """
        :type height: List[int]
        :rtype: int
        """

        left, right = 0, len(height) - 1
        res = 0

        while left < right:
            area = min(height[left], height[right]) * (right - left)
            res = max(res, area)
            if height[left] <= height[right]:
                left += 1
            else:
                right -= 1

        return res


if __name__ == '__main__':
    s1 = Solution_Double_Point()
    height = [1, 8, 6, 2, 5, 4, 8, 3, 7]
    print(s1.maxArea(height))

14. 最长公共前缀 (Easy)

14. 最长公共前缀 (Easy)
思路：

1. zip解法
2. 纵向扫描，见图2
3. 找出数组中字典序最小和最大的字符串,然后遍历
   

图二

"""
    编写一个函数来查找字符串数组中的最长公共前缀。
    如果不存在公共前缀，返回空字符串 ""。

    示例 1：
    输入：strs = ["flower","flow","flight"]
    输出："fl"

    示例 2：
    输入：strs = ["dog","racecar","car"]
    输出：""
    解释：输入不存在公共前缀。

    提示：
    0 <= strs.length <= 200
    0 <= strs[i].length <= 200
    strs[i] 仅由小写英文字母组成
"""
from typing import List


class Solution_zip(object):
    # zip解法,这个解法绝了
    def longestCommonPrefix(self, strs: List[str]) -> str:
        """
        :type strs: List[str]
        :rtype: str
        """
        strs = zip(*strs)
        res = ''
        for i in strs:
            if len(set(i)) == 1:
                res += i[0]
            else:
                break

        return res


class Solution_scan(object):
    # 纵向扫描
    def longestCommonPrefix(self, strs: List[str]) -> str:
        """
        :type strs: List[str]
        :rtype: str
        """
        if not strs:
            return ""

        length, count = len(strs[0]), len(strs)
        for i in range(length):
            for j in range(1, count):
                # i == len(strs[j]) 因为是纵向扫描,所以一旦i不等于len(strs[j])则继续循环也不再有最长公共前缀了
                if strs[j][i] != strs[0][i] or i == len(strs[j]):
                    return strs[0][:i]

        # return strs[0]


class Solution_Min_Max(object):
    # 找出数组中字典序最小和最大的字符串,然后遍历即可
    def longestCommonPrefix(self, strs: List[str]) -> str:
        """
        :type strs: List[str]
        :rtype: str
        """
        if not strs:
            return ""

        # 根据字母顺序排列,并不是按照单词字母的多少排序
        str_min = min(strs)
        str_max = max(strs)

        for i in range(len(str_min)):
            if str_min[i] != str_max[i]:
                return str_min[:i]

        return str_min



if __name__ == '__main__':
    s1 = Solution_scan()
    strs = ["leetcode", "leets", "leet", "leeds"]
    print(s1.longestCommonPrefix(strs))

15. 三数之和 (Medium)

15. 三数之和 (Medium)
思路：排序+双指针

1. 先对数组进行排序；
2. 判断数组首位是否大于0，若大于0，则后面的属于数都会大于0，直接跳出；
3. 固定首个数字为nums[i]，用双指针left,right从nums[i+1]和nums[len(nums)-1]进行首尾移动；
4. 当nums[i]+nums[left]+nums[right]=0时取出三元组结果；
5. 同时在i、left、right移动中需要去除重复数字，避免出现重复结果。

"""
    给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
    注意：答案中不可以包含重复的三元组。

    示例 1：
    输入：nums = [-1,0,1,2,-1,-4]
    输出：[[-1,-1,2],[-1,0,1]]

    示例 2：
    输入：nums = []
    输出：[]

    示例 3：
    输入：nums = [0]
    输出：[]

    提示：
    0 <= nums.length <= 3000
    -105 <= nums[i] <= 10
"""
from typing import List


class Solution(object):
    # 排序+双指针
    # Time complexity: O(N^2)
    # Space complexity: O(1)
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        if len(nums) < 3 or not nums:
            return []

        # 排序
        nums = sorted(nums)
        res = []
        # 固定i,用双指针left,right去遍历寻找nums[i] + nums[left] + nums[right]=0
        for i in range(len(nums)):
            # 若排序后nums[i]依旧大于0,则后面的全部都会大于0
            if nums[i] > 0:
                break
            # 跳过i的重复数据
            if i > 0 and nums[i - 1] == nums[i]:
                continue

            left, right = i + 1, len(nums) - 1
            while left < right:
                sum = nums[i] + nums[left] + nums[right]
                if sum > 0:
                    right -= 1
                elif sum < 0:
                    left += 1
                else:
                    res.append([nums[i], nums[left], nums[right]])
                    # 跳过left的重复数据
                    while left < right and nums[left] == nums[left + 1]:
                        left += 1
                    # 跳过right的重复数据
                    while left < right and nums[right] == nums[right - 1]:
                        right -= 1
                    left += 1
                    right -= 1
        return res

参考资料

• 1
• 2
• 3
• 4
• 5