LeetCode 927. 三等分

本文探讨了如何将一个由0和1组成的数组分成三个非空部分,使这些部分表示相同的二进制值。通过详细解释算法步骤和提供Python代码实现,展示了如何找到满足条件的数组切分点。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

原题地址927. 三等分


给定一个由 0 和 1 组成的数组 A,将数组分成 3 个非空的部分,使得所有这些部分表示相同的二进制值。

如果可以做到,请返回任何 [i, j],其中 i+1 < j,这样一来:

  • A[0], A[1], ..., A[i] 组成第一部分;
  • A[i+1], A[i+2], ..., A[j-1] 作为第二部分;
  • A[j], A[j+1], ..., A[A.length - 1] 是第三部分。
  • 这三个部分所表示的二进制值相等。

如果无法做到,就返回 [-1, -1]

注意,在考虑每个部分所表示的二进制时,应当将其看作一个整体。例如,[1,1,0] 表示十进制中的 6,而不会是 3。此外,前导零也是被允许的,所以 [0,1,1] 和 [1,1] 表示相同的值。

示例 1:
输入:[1,0,1,0,1]
输出:[0,3]

示例 2:
输出:[1,1,0,1,1]
输出:[-1,-1]

提示:
3 <= A.length <= 30000
A[i] == 0 或 A[i] == 1

算法 

就是把数组分成3部分,先保证每部分的1的个数是一样的,以及尾部的0的个数,再转换成整数形式判断值是否相等。


代码 

class Solution:
    def threeEqualParts(self, A):
        """
        :type A: List[int]
        :rtype: List[int]
        """
        sumA = sum(A)
        if sumA == 0:
            return [0, 2]
        if sumA % 3:
            return [-1, -1]
        cal = sumA // 3
        tail0, i = 0, len(A) - 1
        while A[i] == 0:
            i -= 1
            tail0 += 1
        lst = [[], [], []]
        tmp, idx, tail = 0, 0, 0
        for a in A:
            if tmp < cal:
                tmp += a
                lst[idx].append(str(a))
            elif tail < tail0:
                if a == 0:
                    lst[idx].append(str(a))
                    tail += 1
                else:
                    return [-1, -1]
            else:
                tmp, tail = 0, 0
                idx += 1
                tmp += a
                lst[idx].append(str(a))
        if int("".join(lst[0])) == int("".join(lst[1])) == int("".join(lst[2])):
            return [len(lst[0]) - 1, len(lst[0]) + len(lst[1])]
        else:
            return [-1, -1]
<think>我们被要求回答LeetCode70题“爬楼梯”的解题思路,重点在动态规划和递归方法。根据引用内容,我们可以总结如下:1.问题描述:爬楼梯,每次可以爬1或2个台阶,到达第n阶有多少种不同的方法。2.动态规划是解决此问题的典型方法,状态转移方程为:dp[i]=dp[i-1]+dp[i-2]。3.递归方法虽然直观,但存在重复计算,可能导致超时,可以使用记忆化搜索优化(Top-DownDP)。4.动态规划(自底向上)通常使用数组存储中间结果,然后进行空间优化(例如用两个变量代替数组)。我们将按照以下结构组织回答:一、问题描述二、思路分析(递归关系)三、递归方法(及优化)四、动态规划方法(及优化)五、总结同时,根据要求,我们需要在回答末尾生成相关问题。注意:所有数学表达式(包括变量、方程)使用$...$格式,独立公式使用$$...$$格式。回答使用中文。引用标识:在引用的内容末尾添加[^1]、[^2]等,但注意我们引用的内容来自用户提供的引用[1]到[4]。</think>### LeetCode 70:爬楼梯|动态规划与递归解析 #### 一、问题描述 给定楼梯阶数 $n$,每次可爬 $1$ 或 $2$ 阶,求到达第 $n$ 阶的不同方法总数。 #### 二、核心思路 **状态转移方程**: $$ dp[i] = dp[i-1] + dp[i-2] $$ 其中 $dp[i]$ 表示到达第 $i$ 阶的方法数。该方程源于:第 $i$ 阶只能从 $i-1$ 阶(爬 $1$ 阶)或 $i-2$ 阶(爬 $2$ 阶)到达[^2][^4]。 --- #### 三、动态规划解法(推荐) **自底向上迭代**,避免递归重复计算: ```python def climbStairs(n: int) -> int: if n <= 2: return n # 边界处理 dp = [0] * (n+1) dp[1], dp[2] = 1, 2 # 初始状态 for i in range(3, n+1): dp[i] = dp[i-1] + dp[i-2] # 状态转移 return dp[n] ``` **空间优化**(滚动变量): 仅需存储前两个状态,空间复杂度优化至 $O(1)$: ```python def climbStairs(n: int) -> int: if n <= 2: return n a, b = 1, 2 # a=dp[i-2], b=dp[i-1] for _ in range(3, n+1): a, b = b, a + b # 更新状态 return b ``` --- #### 四、递归解法(需优化) **基础递归**(不推荐): 直接实现状态方程,但存在指数级重复计算: ```python def climbStairs(n: int) -> int: if n == 1: return 1 if n == 2: return 2 return climbStairs(n-1) + climbStairs(n-2) # 递归分解 ``` **问题**:计算 $dp[5]$ 需重复计算 $dp[3]$ 和 $dp[4]$,时间复杂度 $O(2^n)$,$n=45$ 时超时[^3]。 **优化:记忆化搜索(Top-Down DP)** 添加缓存避免重复计算,时间复杂度降为 $O(n)$: ```python def climbStairs(n: int) -> int: memo = {} # 记忆字典 def dfs(k): if k <= 2: return k if k not in memo: memo[k] = dfs(k-1) + dfs(k-2) # 缓存结果 return memo[k] return dfs(n) ``` --- #### 五、复杂度对比 | 方法 | 时间复杂度 | 空间复杂度 | 适用性 | |---------------|------------|------------|----------------| | 基础递归 | $O(2^n)$ | $O(n)$ | 仅小 $n$ | | 记忆化搜索 | $O(n)$ | $O(n)$ | 需额外缓存 | | 动态规划 | $O(n)$ | $O(n)$ | 通用 | | **空间优化DP**| $O(n)$ | $O(1)$ | **最优解** | > **总结**:动态规划(尤其空间优化版)是本题最佳解法。其本质是斐波那契数列问题,状态转移方程 $dp[i]=dp[i-1]+dp[i-2]$ 是核心[^1][^2]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值