贪心算法与动态规划的区别与总结(仙道杀招--万我）_动态规划和贪心算法的区别-CSDN博客

本文链接：https://blog.csdn.net/2301_77174919/article/details/144284148

算法设计是程序开发中的核心技能，而贪心算法和动态规划（Dynamic Programming，简称 DP）是两种常用的算法思想。尽管二者在某些问题中都能找到解法，但它们的应用场景和思路截然不同。本文将详细探讨它们的区别，并总结适用场景和特点。

一、基本概念

贪心算法 贪心算法是一种在每一步选择中都采取当前最优策略的算法，希望通过局部最优解推导出全局最优解。它的核心思想是贪婪选择，即每一步都选择能带来当前最大利益的方案。
动态规划 动态规划是一种通过将问题分解为子问题，并存储子问题的解来避免重复计算的方法。它以递归和记忆化搜索为基础，通常适用于有重叠子问题和最优子结构的问题。

二、区别分析

维度	贪心算法	动态规划
思想核心	局部最优推导全局最优	全局最优通过子问题的递推求解
适用问题	最优子结构且贪婪选择策略正确的问题	最优子结构且有重叠子问题的问题
解决过程	直接做出选择，不回溯	构造状态转移方程，存储并递推求解
时间复杂度	通常为 $O(n)$	通常为 $O(n^2)$ 或更高
空间复杂度	$O(1)$ 或 $O(n)$，视具体实现而定	通常为 $O(n)$ 或 $O(n^2)$
解的质量	能解决部分特定问题，可能无法求出最优解	理论保证求出问题的全局最优解
实现难度	简单，直接选择当前最优解即可	较高，需要设计状态和转移方程

三、适用场景

贪心算法的应用场景 贪心算法通常应用于以下场景：
- 活动选择问题最小生成树问题（如 Prim 和 Kruskal 算法）最短路径问题（如 Dijkstra 算法）贪婪换零钱问题（需要货币面值满足某种特性）
示例：区间调度问题给定若干活动的开始和结束时间，选择尽可能多的活动参与，要求活动间不冲突。解决方法是按照结束时间排序，每次选择结束时间最早且与已选活动不冲突的活动。

Go 代码示例：

go
package main

import (
    "fmt"
    "sort"
)

type Activity struct {
    start, end int
}

func maxActivities(activities []Activity) int {
    sort.Slice(activities, func(i, j int) bool {
        return activities[i].end < activities[j].end
    })

    count := 1
    prevEnd := activities[0].end

    for i := 1; i < len(activities); i++ {
        if activities[i].start >= prevEnd {
            count++
            prevEnd = activities[i].end
        }
    }

    return count
}

func main() {
    activities := []Activity{{1, 3}, {2, 5}, {4, 7}, {1, 8}, {5, 9}, {8, 10}}
    fmt.Println("Maximum number of activities:", maxActivities(activities))
}

2. 动态规划的应用场景 动态规划适用于以下场景：

序列问题（如最长公共子序列、最长递增子序列）
背包问题
图论中的最短路径问题（如 Floyd-Warshall 算法）
数学问题（如最小硬币数找零问题）

示例：0/1 背包问题

给定若干物品的重量和价值，在限定总重量内选择物品使总价值最大化。动态规划通过构造一个状态转移表格，从而找到全局最优解。

代码示列：

go

import "fmt"

func knapsack(weights, values []int, capacity int) int {
    n := len(weights)
    dp := make([][]int, n+1)
    for i := range dp {
        dp[i] = make([]int, capacity+1)
    }

    for i := 1; i <= n; i++ {
        for w := 1; w <= capacity; w++ {
            if weights[i-1] <= w {
                dp[i][w] = max(dp[i-1][w], dp[i-1][w-weights[i-1]]+values[i-1])
            } else {
                dp[i][w] = dp[i-1][w]
            }
        }
    }

    return dp[n][capacity]
}

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

func main() {
    weights := []int{1, 2, 3}
    values := []int{6, 10, 12}
    capacity := 5
    fmt.Println("Maximum value in knapsack:", knapsack(weights, values, capacity))
}

四、两者的联系

贪心算法和动态规划的联系主要体现在以下两点：

都需要问题具备最优子结构 也就是说，问题的最优解可以由子问题的最优解构造而来。但贪心算法更依赖贪婪选择的正确性，而动态规划则通过系统性的计算来保证最优解。
某些问题可以两者兼用 某些特殊问题，比如最短路径问题（Dijkstra 算法可以看作贪心），既可以用贪心算法，也可以用动态规划（如 Floyd-Warshall 算法）。