【LeetCode 热题100】BFS/DFS 实战:岛屿数量 & 腐烂的橘子(力扣200 / 994 )(Go语言版)

简介: 本篇博客详细解析了三道经典的动态规划问题:198. 打家劫舍(线性状态转移)、279. 完全平方数与322. 零钱兑换(完全背包问题)。通过 Go 语言实现,帮助读者掌握动态规划的核心思想及其实战技巧。从状态定义到转移方程,逐步剖析每道题的解法,并总结其异同点,助力解决更复杂的 DP 问题。适合初学者深入理解动态规划的应用场景和优化方法。

💰 动态规划实战:打家劫舍、完全平方数与零钱兑换(LeetCode 198 / 279 / 322)

本篇博客一次性带你掌握三道 LeetCode 中经典的动态规划(DP)题目:

  • 🏠 198. 打家劫舍(House Robber)
  • 🟩 279. 完全平方数(Perfect Squares)
  • 💸 322. 零钱兑换(Coin Change)

它们覆盖了动态规划中的线性状态转移完全背包问题,以及最小子结构决策问题


🏠 一、198. 打家劫舍

📌 题目描述

一排房子,每个房子里有一定金额的钱,不能偷相邻的两个房子。求最多能偷多少钱?


💡 解题思路

这是一个典型的线性动态规划问题。

dp[i] 表示前 i 个房子最多能偷的钱:

  • 偷第 i 个房子 → 前 i - 2 个房子最大值 + nums[i]
  • 不偷第 i 个房子 → 前 i - 1 个房子最大值

状态转移方程为:

dp[i] = max(dp[i-1], dp[i-2] + nums[i])

✅ Go 实现(空间优化版)

func rob(nums []int) int {
   
    if len(nums) == 0 {
   
        return 0
    }
    if len(nums) == 1 {
   
        return nums[0]
    }
    prev, curr := 0, 0
    for _, num := range nums {
   
        prev, curr = curr, max(curr, prev+num)
    }
    return curr
}

func max(a, b int) int {
   
    if a > b {
   
        return a
    }
    return b
}

🟩 二、279. 完全平方数

📌 题目描述

给你一个整数 n,将其表示为若干个完全平方数的和,求这些数的最少数量。


💡 解题思路

这是一个典型的完全背包问题。

  • 状态定义:dp[i] 表示组成 i 所需的最少平方数数量;
  • 状态转移:尝试每一个 j*j <= i 的平方数:
dp[i] = min(dp[i], dp[i - j*j] + 1)

✅ Go 实现

func numSquares(n int) int {
   
    dp := make([]int, n+1)
    for i := 1; i <= n; i++ {
   
        dp[i] = i // 最坏情况:1+1+1+...+1
        for j := 1; j*j <= i; j++ {
   
            dp[i] = min(dp[i], dp[i - j*j] + 1)
        }
    }
    return dp[n]
}

func min(a, b int) int {
   
    if a < b {
   
        return a
    }
    return b
}

💸 三、322. 零钱兑换

📌 题目描述

给定不同面额的硬币 coins 和总金额 amount,求最少的硬币数量使得总金额为 amount。如果没有一种组合能组成,返回 -1。


💡 解题思路

也是典型的完全背包问题,区别在于:

  • 目标是最小硬币数
  • 状态定义:dp[i] 表示组成金额 i 所需最少的硬币数
  • 初始化:dp[0] = 0,其余为 inf(表示不可达)

状态转移方程:

dp[i] = min(dp[i], dp[i - coin] + 1)

✅ Go 实现

func coinChange(coins []int, amount int) int {
   
    dp := make([]int, amount+1)
    for i := 1; i <= amount; i++ {
   
        dp[i] = amount + 1
    }

    for _, coin := range coins {
   
        for i := coin; i <= amount; i++ {
   
            dp[i] = min(dp[i], dp[i - coin] + 1)
        }
    }

    if dp[amount] > amount {
   
        return -1
    }
    return dp[amount]
}

🔚 总结对比

题目 本质 状态定义 特点
打家劫舍 线性DP dp[i] 表示前 i 间房最多可偷金额 不能连续取相邻元素
完全平方数 完全背包 dp[i] 表示组成 i 所需的最少平方数个数 类似零钱兑换
零钱兑换 完全背包 dp[i] 表示组成金额 i 最少硬币数 与完全平方数模型一致

📘 写在最后

这三道题虽然看起来背景完全不同,但本质上都属于一维动态规划问题,熟悉它们可以极大提升你解决复杂 DP 问题的能力。

建议继续练习类似题目:

    1. 打家劫舍 II(环形房屋)
    1. 三角形最小路径和
    1. 最长递增子序列

目录
相关文章
|
6月前
|
存储 人工智能 算法
从零掌握贪心算法Java版:LeetCode 10题实战解析(上)
在算法世界里,有一种思想如同生活中的"见好就收"——每次做出当前看来最优的选择,寄希望于通过局部最优达成全局最优。这种思想就是贪心算法,它以其简洁高效的特点,成为解决最优问题的利器。今天我们就来系统学习贪心算法的核心思想,并通过10道LeetCode经典题目实战演练,带你掌握这种"步步为营"的解题思维。
|
10月前
|
Go
【LeetCode 热题100】DP 实战进阶:最长递增子序列、乘积最大子数组、分割等和子集(力扣300 / 152/ 416 )(Go语言版)
本文深入解析三道经典的动态规划问题:**最长递增子序列(LIS)**、**乘积最大子数组** 和 **分割等和子集**。 - **300. LIS** 通过 `dp[i]` 表示以第 `i` 个元素结尾的最长递增子序列长度,支持 O(n²) 动态规划与 O(n log n) 的二分优化。 - **152. 乘积最大子数组** 利用正负数特性,同时维护最大值与最小值的状态转移方程。 - **416. 分割等和子集** 转化为 0-1 背包问题,通过布尔型 DP 实现子集和判断。 总结对比了三题的状态定义与解法技巧,并延伸至相关变种问题,助你掌握动态规划的核心思想与灵活应用!
393 1
|
10月前
|
分布式计算 算法 Go
【LeetCode 热题100】BFS/DFS 实战:岛屿数量 & 腐烂的橘子(力扣200 / 994 )(Go语言版)
本文讲解了两道经典的图论问题:**岛屿数量(LeetCode 200)** 和 **腐烂的橘子(LeetCode 994)**,分别通过 DFS/BFS 实现。在“岛屿数量”中,利用深度或广度优先搜索遍历二维网格,标记连通陆地并计数;“腐烂的橘子”则采用多源 BFS,模拟腐烂传播过程,计算最短时间。两者均需掌握访问标记技巧,是学习网格搜索算法的绝佳实践。
433 1
|
6月前
|
存储 安全 Java
【Golang】(4)Go里面的指针如何?函数与方法怎么不一样?带你了解Go不同于其他高级语言的语法
结构体可以存储一组不同类型的数据,是一种符合类型。Go抛弃了类与继承,同时也抛弃了构造方法,刻意弱化了面向对象的功能,Go并非是一个传统OOP的语言,但是Go依旧有着OOP的影子,通过结构体和方法也可以模拟出一个类。
336 2
|
8月前
|
Cloud Native Go API
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
541 0
|
8月前
|
Cloud Native Java Go
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
364 0
|
8月前
|
Cloud Native Java 中间件
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
415 0
|
8月前
|
Cloud Native Java Go
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
448 0
|
8月前
|
Cloud Native 安全 Java
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
505 1
|
8月前
|
数据采集 Go API
Go语言实战案例:多协程并发下载网页内容
本文是《Go语言100个实战案例 · 网络与并发篇》第6篇,讲解如何使用 Goroutine 和 Channel 实现多协程并发抓取网页内容,提升网络请求效率。通过实战掌握高并发编程技巧,构建爬虫、内容聚合器等工具,涵盖 WaitGroup、超时控制、错误处理等核心知识点。