leecode第14天

2490.回环句

# 句子 是由单个空格分隔的一组单词，且不含前导或尾随空格。

# 例如，"Hello World"、"HELLO"、"hello world hello world" 都是符合要求的句子。
# 单词 仅 由大写和小写英文字母组成。且大写和小写字母会视作不同字符。

# 如果句子满足下述全部条件，则认为它是一个 回环句 ：

# 句子中每个单词的最后一个字符等于下一个单词的第一个字符。
# 最后一个单词的最后一个字符和第一个单词的第一个字符相等。
# 例如，"leetcode exercises sound delightful"、"eetcode"、"leetcode eats soul" 都是回环句。然而，"Leetcode is cool"、"happy Leetcode"、"Leetcode" 和 "I like Leetcode" 都 不 是回环句。

# 给你一个字符串 sentence ，请你判断它是不是一个回环句。如果是，返回 true ；否则，返回 false 。
class Solution(object):
    def isCircularSentence(self, sentence):
        """
        :type sentence: str
        :rtype: bool
        """
        lst=sentence.split(" ")
        fl=lst[0]
        ls=lst[-1]
        if fl[0]==ls[-1]:
            s=0
            for i in range(len(lst)-1):
                if lst[i][-1]!=lst[i+1][0]:
                    s+=1
            if s==0:
                return True
            else:
                return False
        else:
            return False     

问题分析与优化建议

潜在问题

1. 异常处理不足：代码假设输入的 sentence 是一个合法的字符串，但如果输入为空字符串 ("") 或仅包含空格时，可能会导致逻辑错误或边界条件未被正确处理。
2. 变量命名不够清晰：变量如 fl, ls, s 等命名过于简短，缺乏语义性，降低了代码的可读性和可维护性。
3. 冗余逻辑：if s == 0: return True; else: return False 可以直接简化为 return s == 0，减少不必要的分支判断。
4. 边界条件未完全覆盖：当 lst 中只有一个单词时，代码逻辑未明确处理这种情况。

优化方向

1. 增强健壮性：增加对空字符串和仅含空格的输入的检查，确保代码能够正确处理这些边界情况。
2. 改进变量命名：使用更具描述性的变量名，提高代码的可读性。
3. 简化逻辑：移除冗余的分支判断，使代码更加简洁。
4. 性能优化：当前代码的时间复杂度为 O(n)，已经是线性复杂度，无需进一步优化性能。

def isCircularSentence(self, sentence):
    """
    :type sentence: str
    :rtype: bool
    """
    # 处理空字符串或仅含空格的情况
    if not sentence or sentence.isspace():
        return False

    # 分割句子为单词列表
    words = sentence.split(" ")

    # 如果单词列表为空，返回 False
    if len(words) == 0:
        return False

    # 检查首尾单词是否满足循环条件
    if words[0][0] != words[-1][-1]:
        return False

    # 遍历单词列表，检查相邻单词的连接是否满足循环条件
    for i in range(len(words) - 1):
        if words[i][-1] != words[i + 1][0]:
            return False

    # 所有条件均满足，返回 True
    return True

LCR 073.爱吃香蕉的狒狒

# 狒狒喜欢吃香蕉。这里有 N 堆香蕉，第 i 堆中有 piles[i] 根香蕉。警卫已经离开了，将在 H 小时后回来。

# 狒狒可以决定她吃香蕉的速度 K （单位：根/小时）。每个小时，她将会选择一堆香蕉，从中吃掉 K 根。如果这堆香蕉少于 K 根，她将吃掉这堆的所有香蕉，然后这一小时内不会再吃更多的香蕉，下一个小时才会开始吃另一堆的香蕉。  

# 狒狒喜欢慢慢吃，但仍然想在警卫回来前吃掉所有的香蕉。

# 返回她可以在 H 小时内吃掉所有香蕉的最小速度 K（K 为整数）。

class Solution(object):
    def minEatingSpeed(self, piles, h):
        """
        计算在h小时内吃完所有香蕉的最小速度k。
        
        参数:
        piles: List[int] - 每堆香蕉的数量列表。
        h: int - 可用来吃香蕉的小时数。
        
        返回:
        int - 能在h小时内吃完所有香蕉的最小速度k。
        """
        # 从1到最大堆的数量迭代，寻找最小的速度k
        for k in range(1, max(piles)):
            H = 0
            # 遍历每堆香蕉，计算当前速度k下的总小时数H
            for i in range(len(piles)):
                # 如果当前堆的香蕉数量能被k整除，直接除以k得到消耗的小时数
                if piles[i] % k == 0:
                    H += piles[i] // k
                else:
                    # 如果不能被整除，则需要额外加1个小时来吃完这堆香蕉
                    H += piles[i] // k + 1
            # 如果当前速度k下的总小时数H不超过h，则返回当前的速度k
            if H <= h:
                return k

问题分析与优化建议

潜在问题

1. 效率低下：使用线性搜索来寻找最小速度 k，时间复杂度为 (O(n \cdot m))，其中 (n) 是 piles 的长度，(m) 是搜索范围的大小。这种效率在数据量较大时会非常低效。
2. 边界条件未处理：如果 h < len(piles)，则无论如何都无法完成任务，应直接返回 -1 或抛出异常。

优化方向

1. 改用二分查找：将线性搜索替换为二分查找，时间复杂度降低至 (O(n \cdot \log(m)))。
2. 改进变量命名：使用更具描述性的变量名，提高代码可读性。
3. 优化边界条件：提前判断无效输入，减少不必要的计算。

class Solution(object):
    def minEatingSpeed(self, piles, h):
        """
        :type piles: List[int]
        :type h: int
        :rtype: int
        """
        # 输入校验
        if not piles or h <= 0:
            raise ValueError("Invalid input: 'piles' must be non-empty and 'h' must be positive.")
        
        # 如果 h 小于香蕉堆的数量，无论如何都无法完成任务
        if h < len(piles):
            return -1
        
        # 定义二分查找的左右边界
        left, right = 1, max(piles)
        
        while left < right:
            mid = (left + right) // 2
            hours_needed = 0
            
            # 计算以速度 mid 吃完所有香蕉所需的小时数
            for pile in piles:
                hours_needed += (pile + mid - 1) // mid  # 等价于 math.ceil(pile / mid)
            
            if hours_needed > h:
                # 如果所需时间超过 h，则增加速度
                left = mid + 1
            else:
                # 否则尝试更小的速度
                right = mid
        
        return left