【算法题】动态规划基础阶段之买卖股票的最佳时机、比特位计数、判断子序列_股票买卖算法题

前言

动态规划（Dynamic Programming，简称 DP）是一种解决多阶段决策过程最优化问题的方法。它是一种将复杂问题分解成重叠子问题的策略，通过维护每个子问题的最优解来推导出问题的最优解。

动态规划的主要思想是利用已求解的子问题的最优解来推导出更大问题的最优解，从而避免了重复计算。因此，动态规划通常采用自底向上的方式进行求解，先求解出小规模的问题，然后逐步推导出更大规模的问题，直到求解出整个问题的最优解。

动态规划通常包括以下几个基本步骤：

1. 定义状态：将问题划分为若干个子问题，并定义状态表示子问题的解；
2. 定义状态转移方程：根据子问题之间的关系，设计状态转移方程，即如何从已知状态推导出未知状态的计算过程；
3. 确定初始状态：定义最小的子问题的解；
4. 自底向上求解：按照状态转移方程，计算出所有状态的最优解；
5. 根据最优解构造问题的解。

动态规划可以解决许多实际问题，例如最短路径问题、背包问题、最长公共子序列问题、编辑距离问题等。同时，动态规划也是许多其他算法的核心思想，例如分治算法、贪心算法等。

动态规划是一种解决多阶段决策过程最优化问题的方法，它将复杂问题分解成重叠子问题，通过维护每个子问题的最优解来推导出问题的最优解。动态规划包括定义状态、设计状态转移方程、确定初始状态、自底向上求解和构造问题解等步骤。动态规划可以解决许多实际问题，也是其他算法的核心思想之一。

一、买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

来源：力扣（LeetCode）。

1.1、思路

动态规划一般分为一维、二维、多维（使用 状态压缩），对应形式为 dp[i]、dp[i][j]、二进制dp[i][j]。

• 明确 dp[i]应该表示什么。
• 根据 dp[i] 和 dp[i-1]的关系得出状态转移方程。
• 确定初始条件，如 dp(0)。

dp[i] 表示前 i 天的最大利润，因为我们始终要使利润最大化，则状态转移方程：
dp[i]=max(dp[i−1],prices[i]−minprice)。

1.2、代码实现

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n=prices.size();
        if(n==0)
            return 0;
        int minPrice=prices[0];
        vector<int> dp(n,0);
        // 初始条件
        dp[0]=0;
        for(int i=1;i<n;i++)
        {
            minPrice=min(minPrice,prices[i]);
            dp[i]=max(dp[i-1],prices[i]-minPrice);
        }
        return dp[n-1];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

时间复杂度：O(n)。
空间复杂度：O(n)。

二、比特位计数

给你一个整数 n ，对于 0 <= i <= n 中的每个 i ，计算其二进制表示中 1 的个数 ，返回一个长度为 n + 1 的数组 ans 作为答案。

示例 1：

输入：n = 2
输出：[0,1,1]
解释：
0 --> 0
1 --> 1
2 --> 10

示例 2：

输入：n = 5
输出：[0,1,1,2,1,2]
解释：
0 --> 0
1 --> 1
2 --> 10
3 --> 11
4 --> 100
5 --> 101

来源：力扣（LeetCode）。

2.1、思路

分奇数和偶数：

• 偶数的二进制1个数超级简单，因为偶数是相当于被某个更小的数乘2，乘2怎么来的？在二进制运算中，就是左移一位，也就是在低位 多加1个0，那样就说明dp[i] = dp[i / 2]。
• 奇数稍微难想到一点，奇数由不大于该数的偶数+1得到，偶数+1在二进制位上会发生什么？会在低位多加1个1，那样就说明dp[i] = dp[i-1] + 1，当然也可以写成dp[i] = dp[i / 2] + 1。

对于所有的数字，只有两类：

奇数：二进制表示中，奇数一定比前面那个偶数多一个 1，因为多的就是最低位的 1。

         0 = 0       1 = 1
         2 = 10      3 = 11
1
2

偶数：二进制表示中，偶数中 1 的个数一定和除以 2 之后的那个数一样多。因为最低位是 0，除以 2 就是右移一位，也就是把那个 0 抹掉而已，所以 1 的个数是不变的。

          2 = 10       4 = 100       8 = 1000
          3 = 11       6 = 110       12 = 1100
1
2

另外，0 的 1 个数为 0，于是就可以根据奇偶性开始遍历计算了。

2.2、代码实现

状态方程：dp[i]=dp[i>>1]+(i&1)。

class Solution {
public:
    vector<int> countBits(int n) {
        vector<int> ans(n+1,0);
        for(int i=0;i<=n;i++)
        {
            ans[i]=ans[i>>1]+(i&0x01);
        }
        return ans;
    }
};
1
2
3
4
5
6
7
8
9
10
11

时间复杂度：O(n)。对于每个整数，只需要 O(1) 的时间计算「一比特数」。

空间复杂度：O(1)。除了返回的数组以外，空间复杂度为常数。

三、 判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

示例 1：

输入：s = “abc”, t = “ahbgdc”
输出：true

示例 2：

输入：s = “axc”, t = “ahbgdc”
输出：false

来源：力扣（LeetCode）。

3.1、思路

如果用枚举的方式会有大量的时间用于在 t 中找到下一个匹配字符。可以预处理出对于 t 的每一个位置，从该位置开始往后每一个字符第一次出现的位置。
可以使用动态规划的方法实现预处理，令 f[i][j] 表示字符串 t 中从位置 i 开始往后字符 j 第一次出现的位置。在进行状态转移时，如果 t 中位置 i 的字符就是 j，那么 f[i][j]=i，否则 j 出现在位置 i+1 开始往后，即 f[i][j]=f[i+1][j]，因此要倒过来进行动态规划，从后往前枚举 i。

这样可以写出状态转移方程：

3.2、代码实现

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n = s.size(), m = t.size();

        vector<vector<int> > f(m + 1, vector<int>(26, 0));
        for (int i = 0; i < 26; i++) {
            f[m][i] = m;
        }

        for (int i = m - 1; i >= 0; i--) {
            for (int j = 0; j < 26; j++) {
                if (t[i] == j + 'a')
                    f[i][j] = i;
                else
                    f[i][j] = f[i + 1][j];
            }
        }
        int add = 0;
        for (int i = 0; i < n; i++) {
            if (f[add][s[i] - 'a'] == m) {
                return false;
            }
            add = f[add][s[i] - 'a'] + 1;
        }
        return true;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

这就把ID改成“万物DP”。

总结

动态规划（Dynamic Programming）是一种解决多阶段决策最优化问题的方法，它将复杂问题分解成重叠子问题并通过维护每个子问题的最优解来推导出问题的最优解。动态规划可以解决许多实际问题，例如最短路径问题、背包问题、最长公共子序列问题、编辑距离问题等。

动态规划的基本思想是利用已求解的子问题的最优解来推导出更大问题的最优解，从而避免了重复计算。它通常采用自底向上的方式进行求解，先求解出小规模的问题，然后逐步推导出更大规模的问题，直到求解出整个问题的最优解。

动态规划通常包括以下几个基本步骤：

1. 定义状态：将问题划分为若干个子问题，并定义状态表示子问题的解；
2. 定义状态转移方程：根据子问题之间的关系，设计状态转移方程，即如何从已知状态推导出未知状态的计算过程；
3. 确定初始状态：定义最小的子问题的解；
4. 自底向上求解：按照状态转移方程，计算出所有状态的最优解；
5. 根据最优解构造问题的解。

动态规划的时间复杂度通常为$O(n^2)$或$O(n^3)$，空间复杂度为O(n)，其中n表示问题规模。在实际应用中，为了减少空间复杂度，通常可以使用滚动数组等技巧来优化动态规划算法。