动态规划太复杂？动态规划到底怎么优化？看完这篇文章彻底搞懂

干货没人看

于 2024-08-13 09:38:50 发布

阅读量923

点赞数 33

文章标签： c语言 c++ 经验分享算法 python

本文链接：https://blog.csdn.net/qq_36916968/article/details/141155420

版权

你以为动态规划就这么简单？别急，优化才是真正的王者技！

很多人都认为动态规划不过是个套公式的游戏，定义状态、写转移方程，然后就能“躺平”收获最优解。你是不是也这么想的？然而，真的是这样吗？大多数初学者一头扎进DP的世界里，却在优化的泥沼中越陷越深。

但今天，我要告诉你一个秘密：优化才是动态规划中的“王炸”。这个技术可以把你从“内存不足”的绝望中拯救出来，让你的算法飞速提升。

动态规划的秘密武器——状态定义

首先，我们来揭开DP的神秘面纱。动态规划的核心在于什么？是“状态定义”。你以为这只是简单的数组操作？大错特错！**每个DP表格背后，都蕴藏着一个深不见底的智慧海洋。**定义状态的过程，实际上是在为原问题铺路，为后续的优化打下基础。

比如，求解最长公共子序列问题时，我们定义dp[i][j]表示字符串A的前i个字符和字符串B的前j个字符的最长公共子序列长度。这一步看似简单，但实际上，你已经在无形中决定了问题的“命运”。

你以为状态转移方程很简单？再想想！

接下来，进入了“地狱难度”的状态转移方程环节。这就是动态规划的灵魂所在！很多人以为状态转移方程不过是几行代码的事，但如果你不理解其中的逻辑，那它永远会是你心中的一道坎。

以最长公共子序列为例，转移方程如下：

如果A[i] == B[j]，那么dp[i][j] = dp[i-1][j-1] + 1。
否则，dp[i][j] = max(dp[i-1][j], dp[i][j-1])。

是不是感觉似曾相识？但请记住，这不是简单的数学公式，而是无数人掉进的坑。每一个max都代表了一个选择，而这个选择的背后是你对问题理解的深度。

滚动优化——让你的算法像火箭一样起飞

好，现在进入真正的高潮部分：滚动优化！你以为动态规划已经很牛了？那是你还没见识过它的“超级形态”。滚动优化才是真正让你脱胎换骨的秘诀。

你可能觉得DP的二维表格用着挺爽，但当数据量上去后，你的内存会崩溃地哭喊：“太多了！撑不住了！”这时候，滚动优化登场了——我们不再用一个庞大的二维数组，而是只用两个一维数组，就能搞定所有问题！

这意味着什么？空间复杂度直接砍掉一半！，在巨大的数据面前，你的算法依然可以像轻风一样飘过。

int longestCommonSubsequence(string text1, string text2) {
    int n = text1.size(), m = text2.size();
    vector<int> prev(m+1, 0), curr(m+1, 0);

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            if (text1[i-1] == text2[j-1]) {
                curr[j] = prev[j-1] + 1;
            } else {
                curr[j] = max(prev[j], curr[j-1]);
            }
        }
        prev = curr;
    }
    return prev[m];
}

看到这里，你可能会想：“不就是少了几行代码吗？”但别小看了这几行，它们可是将空间复杂度从O(n * m)直接削减到O(m)的关键！在你不经意之间，这个小小的技巧已经帮你节省了大量的内存资源。

别急！刚刚只是开始，高级炫技才刚刚拉开帷幕。接下来，我们进入DP世界中的“王者段位”——用一系列令人目眩的高级技巧带你深入理解动态规划的真正精髓。准备好了吗？咱们上干货！

例子一：最长回文子序列——反转中的精妙之处

当我们谈到回文时，大多数人脑海里浮现的是什么？对称、美丽、简洁……但在算法中，回文却是个刁钻的考验，尤其是“最长回文子序列”这个问题。

你可能认为，这不过是最长公共子序列的一个变种，对吧？可事实是，它比你想象的要复杂得多。为什么呢？因为这个问题不仅要找出子序列，还得保证它是回文的！这就好比让你在一堆乱麻中捋出一条完美的曲线。

状态定义和转移方程的“极限操作”

首先，我们要定义dp[i][j]表示字符串S从i到j之间的最长回文子序列长度。听起来简单？那是你还没看到它的转移方程。

如果S[i] == S[j]，那么dp[i][j] = dp[i+1][j-1] + 2。
否则，dp[i][j] = max(dp[i+1][j], dp[i][j-1])。

这两行代码看似平常，实际上是对字符串进行极限“剪裁”和“反转”操作。每一步，都在对字符进行细致入微的“权衡”。最终，你会发现，一个美丽的回文子序列在这些操作中被雕琢得近乎完美。

滚动优化——在对称中寻求简洁

再说到优化，这个问题又给了我们一个大礼——我们只需要关注字符串的一半！在对称的性质下，滚动优化显得更加得心应手。我们可以用一个二维数组的半边来完成所有操作，从而将空间复杂度减半。

int longestPalindromeSubseq(string s) {
    int n = s.size();
    vector<int> dp(n, 1);

    for (int i = n - 1; i >= 0; --i) {
        int len = 0;
        for (int j = i + 1; j < n; ++j) {
            int tmp = dp[j];
            if (s[i] == s[j]) {
                dp[j] = len + 2;
            } 
            len = max(len, tmp);
        }
    }
    return *max_element(dp.begin(), dp.end());
}

简单的几行代码，却将你从“内存吃紧”的泥潭中救出，并让你轻松应对大规模数据。如此优雅的设计，怎能不让人拍案叫绝？

最长递增子序列——隐藏在复杂度中的宝藏

接下来，让我们看看“最长递增子序列”（LIS）。这看似是一个简单的DP问题，但实际上，它背后隐藏着一块巨大的宝藏。

许多人在解决LIS时，都会使用O(n^2)的朴素DP方法。但今天我要告诉你的是，LIS的问题绝不止步于此！通过巧妙的结合DP和二分查找，我们能把这个问题的复杂度压缩到O(n log n)。

DP与二分查找的“黄金搭档”

首先，我们仍然定义dp[i]为以nums[i]结尾的最长递增子序列的长度。然而，真相是，我们并不需要显式地计算出每一个dp[i]。我们可以通过维护一个“最优序列”，利用二分查找来动态更新这个序列的每一个元素，从而高效地找到LIS的长度。

int lengthOfLIS(vector<int>& nums) {
    vector<int> dp;

    for (int num : nums) {
        auto it = lower_bound(dp.begin(), dp.end(), num);
        if (it == dp.end()) {
            dp.push_back(num);
        } else {
            *it = num;
        }
    }
    return dp.size();
}

看到了吗？在这个算法中，二分查找与DP完美结合，实现了从O(n^2)到O(n log n)的惊人提升。这不仅是一个复杂度的改进，更是一种算法设计思想的升华。如此美妙的配合，就像是乐队中的灵魂演奏家和节拍器的完美结合，让问题在不经意间解决得如此优雅。

背包问题——当约束成为优化的动力

最后，我们来看看背包问题。这个经典的NP完全问题一直是DP的“试金石”。许多算法新手都在这里栽过跟头，但老手们却知道如何将约束条件转化为优化的机会。

在01背包问题中，我们要处理的是一个二选一的决策问题：要么选择这个物品，要么放弃。显然，这里有一种天然的递归结构，但直接的DP实现可能会让你在内存上“叫苦连天”。这时，滚动优化再次登场——它可以将空间复杂度从O(n * W)减少到O(W)，其中W是背包的容量。

int knapSack(int W, vector<int>& wt, vector<int>& val, int n) {
    vector<int> dp(W + 1, 0);

    for (int i = 0; i < n; ++i) {
        for (int w = W; w >= wt[i]; --w) {
            dp[w] = max(dp[w], dp[w - wt[i]] + val[i]);
        }
    }
    return dp[W];
}