Dynamic Programming on Hang Zhang

Maximum Contiguous Subsequence

Thu, 10 Apr 2025 00:00:00 +0000

最大连续子序列

给定 K 个整数的序列 {N0, N1, …, NK − 1}，其任意连续子序列可表示为 {Ni, Ni + 1, …, Nj}，其中 0 ≤ i ≤ j < K

最大连续子序列是所有连续子序列中元素和最大的一个，例如给定序列 {−2, 11, −4, 13, −5, −2}，其最大连续子序列为 {11, −4, 13} ，最大和为 20

编写程序得到其中最大子序列的和并输出该子序列的第一个和最后一个元素的下标

输入格式

输入包含多组测试数据

每组数据占 2 行，第 1 行给出正整数 K

第 2 行给出 K 个整数 N1, …, NK

输出格式

每组数据输出一行结果，包含最大子序列的和以及子序列的第一个下标 i 和最后一个元素的下标 j

所有元素下标为 0 ∼ K − 1

如果最大子序列不唯一，则选择 i 最小的那个子序列，如果仍不唯一，则选择 i 最小的子序列中 j 最小的那个子序列

若所有 K 个元素都是负数，则定义其最大和为 0，输出 0 0 0

数据范围

1 ≤ K ≤ 105, −10000 ≤ Ni ≤ 10000, 输入最多包含 10 组数据

输入样例：

8
6 -2 11 -4 13 -5 -2 10
5
10 -10 10 -10 10
8
-1 -5 -2 3 -1 0 -2 0
4
-1 -2 -4 -3

输出样例：

分析

last：当前以第 i 个元素结尾的子序列最大和
若 last < 0，则从当前元素重新开始，记录当前左端点 temp
如果当前 last 优于全局最大 res，则更新 res 和左右端点

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

#include <iostream>
#include <climits>

const int N = 100010;
int nums[N];

int main()
{
  int n;

  while (std::cin >> n)
  {
    for (int i = 0; i < n; ++i)
      std::cin >> nums[i];

    int last = 0;                   // 当前子段和
    int res = INT_MIN;             // 最大子段和
    int l = 0, r = 0;              // 结果子序列的起止下标
    int temp = 0;                  // 记录当前子段的起点

    for (int i = 0; i < n; ++i)
    {
      // 如果前缀和为负，丢弃，重开新子段，并记录左端点
      if (last < 0)
        temp = i;

      last = std::max(nums[i], last + nums[i]);

      if (res < last)
      {
        res = last;
        l = temp;                  // 更新起点为当前有效起点
        r = i;                     // 终点为当前下标
      }
    }

    if (res < 0)
      std::cout << "0 0 0" << '\n';  // 所有数都为负数
    else
      std::cout << res << ' ' << l << ' ' << r << '\n';
  }

  return 0;
}

Maximal Square

Mon, 24 Feb 2025 00:00:00 +0000

221. 最大正方形

分析

初始化：
- n 和 m 分别为矩阵的行数和列数。
- 状态表示：f[i][j] 表示以 matrix[i-1][j-1] 为右下角的最大正方形的边长
状态转移：
- 对于每一个 matrix[i - 1][j - 1] == '1'，我们通过状态转移方程更新 f[i][j] 的值
- f[i][j] 的值是通过左边、上边和左上角的最小值加 1 来计算的，表示我们可以扩展一个更大的正方形：f[i][j] = min(f[i-1][j], f[i][j-1], f[i-1][j-1]) + 1
更新最大边长：
- 每次更新 f[i][j] 时，比较当前 f[i][j] 的值是否大于当前最大边长 res，如果大于，则更新 res
返回结果：
- 最终返回的结果是 res * res，即最大正方形的面积

时间复杂度

时间复杂度 O(n * m)

空间复杂度

空间复杂度为 O(n * m)

C++代码

class Solution
{
public:
    int maximalSquare(vector<vector<char>>& matrix)
    {
        // 判断输入矩阵是否为空
        if (matrix.empty() || matrix[0].empty())
            return 0;

        int n = matrix.size(), m = matrix[0].size();

        // 初始化状态表示 f，大小为 (n+1) * (m+1)
        std::vector<std::vector<int>> f(n + 1, std::vector<int>(m + 1));
        int res = 0;  // 存储最大正方形的边长

        // 遍历矩阵每个元素
        for (int i = 1; i <= n; ++i)
            for (int j = 1; j <= m; ++j)
                if (matrix[i - 1][j - 1] == '1')  // 如果当前位置是 '1'
                {
                    // 更新 f[i][j] 为左边、上边和左上角最小值加 1
                    f[i][j] = std::min(f[i - 1][j], std::min(f[i][j - 1], f[i - 1][j - 1])) + 1;
                    // 更新最大正方形边长
                    res = std::max(res, f[i][j]);
                }

        // 返回最大正方形的面积
        return res * res;
    }
};

Best Time to Buy and Sell Stock IV

Sun, 23 Feb 2025 00:00:00 +0000

188. 买卖股票的最佳时机IV

分析

无交易限制的情况：
- 当 k >= n / 2（即可以无限次交易的情况），那么我们可以通过每次只要当前价格比前一天高就进行交易，获取利润
- 这种情况下，我们只需要遍历数组，当 prices[i] < prices[i + 1] 时，进行买卖，利润就会累加
有交易次数限制的情况：
- 当 k < n / 2 时，我们需要考虑最多进行 k 次交易的情况。为此，我们需要使用动态规划来计算不同交易次数的最大利润
- 使用动态规划状态 f[i][j] 表示前 i 天内进行 j 次交易的最大利润。我们还可以使用辅助数组 g[i][j] 来记录前 i 天内进行 j-1 次交易，买入股票时的状态（即股票买入价格的最优状态）
- 每次更新 f[i][j] 和 g[i][j] 时，考虑的是：
  - 卖出：通过 g[i-1][j] + prices[i-1] 来记录前 i-1 天完成 j 次交易的最大利润加上当前价格（即卖出）
  - 买入：通过 f[i-1][j-1] - prices[i-1] 来记录前 i-1 天完成 j-1 次交易的最大利润减去当前价格（即买入）
状态转移方程
- f[i][j] = max(f[i-1][j], g[i-1][j] + prices[i-1])：卖出时，选择前 i-1 天进行 j 次交易的最大利润，再加上今天卖出的利润
- g[i][j] = max(g[i-1][j], f[i-1][j-1] - prices[i-1])：买入时，选择前 i-1 天进行 j-1 次交易的最大利润，再减去今天买入的价格

时间复杂度

时间复杂度 O(k * n)

空间复杂度

空间复杂度为 O(k * n)

C++代码

class Solution
{
public:
    int maxProfit(int k, vector<int>& prices)
    {
        int res = 0;
        int n = prices.size();

        // 交易次数 k 大于等于 n / 2，则可以进行无限次交易
        if (k >= n / 2)
        {
            for (int i = 0; i < n - 1; ++i)
                if (prices[i] < prices[i + 1])
                    res += prices[i + 1] - prices[i];  // 贪心：只要后一天价格高于前一天就交易
            return res;
        }

        int INF = 0x3f3f3f3f;
        vector<vector<int>> f(n + 1, vector<int>(k + 1, -INF));  // 动态规划数组，初始化为一个大负值
        vector<vector<int>> g = f;  // 辅助数组，用于存储买入操作时的状态

        f[0][0] = 0;  // 在第 0 天，不进行任何交易，利润为 0

        // 遍历每一天
        for (int i = 1; i <= n; ++i)
            for (int j = 0; j <= k; ++j)
            {
                // 若不做交易，利润保持不变。若交易，进行卖出操作
                f[i][j] = max(f[i - 1][j], g[i - 1][j] + prices[i - 1]);

                g[i][j] = g[i - 1][j];  // 不进行买入操作

                if (j)  // 如果可以进行交易
                    g[i][j] = max(g[i][j], f[i - 1][j - 1] - prices[i - 1]);  // 进行买入操作

                res = max(res, f[i][j]);  // 更新最大利润
            }

        return res;  // 返回最终的最大利润
    }
};

Best Time to Buy and Sell Stock III

Sat, 22 Feb 2025 00:00:00 +0000

123. 买卖股票的最佳时机III

分析

为了计算出最大利润，可以将问题拆解成两个阶段：

第一笔交易：计算在前几天内，买入并卖出获得的最大利润
第二笔交易：计算在后几天内，买入并卖出获得的最大利润，并与第一笔交易的最大利润结合

第一次交易：
- 初始化一个数组 f，用来记录前 i 天结束时的最大利润
- 变量 minp 用来记录前 i 天中的最低股价。在每一天，计算当前股价和 minp 的差值，更新 f[i] 为当前的最大利润
第二次交易：
- 在完成第一次交易后，我们从后往前遍历 prices 数组，计算从第 i 天开始的最大卖出利润 maxp - prices[i-1]，然后将其与 f[i-1]（表示前 i-1 天的最大利润）合并得到总利润
最终结果：
- res 记录的是两次交易合并的最大利润

时间复杂度

时间复杂度 O(n)，遍历 prices 数组两次

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int maxProfit(vector<int>& prices)
    {
        int n = prices.size();

        // f[i] 表示前 i 天结束时的最大利润
        std::vector<int> f(n + 1);

        // 计算第一次交易的最大利润
        for (int i = 1, minp = INT_MAX; i <= n; ++i)
        {
            f[i] = std::max(f[i - 1], prices[i - 1] - minp);  // max(不交易, 卖出利润)
            minp = std::min(minp, prices[i - 1]);  // 更新最小买入价格
        }

        int res = 0;

        // 计算第二次交易的最大利润
        for (int i = n, maxp = 0; i > 0; --i)
        {
            // 计算第二次交易和第一次交易合并的最大利润
            res = std::max(res, maxp - prices[i - 1] + f[i - 1]);
            maxp = std::max(maxp, prices[i - 1]);  // 更新最大卖出价格
        }

        return res;
    }
};

Interleaving String

Fri, 21 Feb 2025 00:00:00 +0000

97. 交错字符串

分析

初始化：
- 先计算 s1 和 s2 的长度 n 和 m，并检查 s3 的长度是否为 n + m。如果不是，直接返回 false
- 为了方便处理边界情况，我们给 s1、s2 和 s3 的开头加上一个空格 ' '，这样可以简化状态转移的边界处理
状态表示 f：
- f[i][j] 表示由 s1 的前 i 个字符和 s2 的前 j 个字符是否能交错组成 s3 的前 i + j 个字符。
- 初始化 f[0][0] = true，表示空的 s1 和空的 s2 能交错组成空的 s3
动态规划转移：
- 对于每一个 i 和 j，检查当前字符是否匹配：
- 如果 s1[i] 和 s3[i + j] 相等，则可以从 f[i-1][j] 更新到 f[i][j]
- 如果 s2[j] 和 s3[i + j] 相等，则可以从 f[i][j-1] 更新到 f[i][j]
结果返回：
- 最终返回 f[n][m]，即判断 s1 和 s2 是否能够交错组成 s3

时间复杂度

时间复杂度 O(n * m)，其中 n 是 s1 的长度，m 是 s2 的长度

空间复杂度

空间复杂度为 O(n * m)

C++代码

class Solution
{
public:
    bool isInterleave(string s1, string s2, string s3)
    {
        int n = s1.size(), m = s2.size();

        // 如果 s3 的长度不等于 s1 和 s2 的长度之和，直接返回 false
        if (s3.size() != n + m)
            return false;

        // 加上空字符方便处理边界情况
        s1 = ' ' + s1;
        s2 = ' ' + s2;
        s3 = ' ' + s3;

        // 初始化状态表示f
        std::vector<std::vector<bool>> f(n + 1, std::vector<bool>(m + 1));

        // 状态转移
        for (int i = 0; i <= n; ++i)
        {
            for (int j = 0; j <= m; ++j)
            {
                if (i == 0 && j == 0)
                    // 起始点，空的 s1 和 s2 可以交错组成空的 s3
                    f[i][j] = true;
                else
                {
                    // 如果 s1[i] == s3[i + j]，则可以从 f[i-1][j] 更新到 f[i][j]
                    if (i && s1[i] == s3[i + j])
                        f[i][j] = f[i - 1][j];
                    // 如果 s2[j] == s3[i + j]，则可以从 f[i][j-1] 更新到 f[i][j]
                    if (j && s2[j] == s3[i + j])
                        f[i][j] = f[i][j] || f[i][j - 1];
                }
            }
        }

        // 返回结果
        return f[n][m];
    }
};

Unique Paths II

Thu, 20 Feb 2025 00:00:00 +0000

63. 不同路径II

分析

状态定义：f[i][j] 代表从起点 (0, 0) 到达 (i, j) 的路径数
状态转移：
- 如果 obstacleGrid[i][j] == 0，表示当前位置可以走（没有障碍物），我们根据递推公式更新路径数：
  - 如果当前位置是起点 (0, 0)，则 f[0][0] = 1
  - 否则，当前位置的路径数由上方和左方的路径数之和 f[i][j] = f[i-1][j] + f[i][j-1] 得出
- 如果 obstacleGrid[i][j] == 1，说明当前位置有障碍物，不能走到这里，无需处理 f[i][j]，因为初始的 f[i][j] 值为 0
返回最终结果：循环结束后，f[n-1][m-1] 就是从起点到终点的不同路径数

时间复杂度

时间复杂度 O(n * m)

空间复杂度

空间复杂度为 O(n * m)

C++代码

class Solution
{
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid)
    {
        int n = obstacleGrid.size(), m = obstacleGrid[0].size();
        // 初始化 DP 数组
        std::vector<std::vector<int>> f(n, std::vector<int>(m));

        // 遍历每个格子
        for (int i = 0; i < n; ++ i)
            for (int j = 0; j < m; ++ j)
                if (obstacleGrid[i][j] == 0)  // 如果当前格子没有障碍物
                {
                    if (i == 0 && j == 0)  // 起始位置
                        f[i][j] = 1;  // 从起点出发，路径数为 1
                    else
                    {
                        if (i)  // 如果不在第一行
                            f[i][j] += f[i - 1][j];  // 从上方格子来的路径数
                        if (j)  // 如果不在第一列
                            f[i][j] += f[i][j - 1];  // 从左方格子来的路径数
                    }
                }

        return f[n - 1][m - 1];  // 返回右下角的路径数
    }
};

Triangle

Wed, 19 Feb 2025 00:00:00 +0000

120. 三角形最小路径和

分析

状态定义：triangle[i][j] 表示从底层到第i行j列节点的最小路径和
状态转移：triangle[i][j] 的值等于下一层相邻节点中的较小值 + 当前节点值: triangle[i][j] += std::min(triangle[i + 1][j], triangle[i + 1][j + 1])
最终，triangle[0][0] 中存储的就是从底端到顶端的最小路径和

时间复杂度

时间复杂度 O(n^2)，其中 n 是三角形的行数。每一行最多有 n 个元素，处理每个元素时需要计算两个相邻节点的最小值

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int minimumTotal(vector<vector<int>>& triangle)
    {
        // 从倒数第二行开始，向上更新最小路径和
        for (int i = triangle.size() - 2; i >= 0; --i)
            for (int j = 0; j < triangle[i].size(); ++j)  // 遍历每一行的元素
                triangle[i][j] += std::min(triangle[i + 1][j], triangle[i + 1][j + 1]);  // 更新当前点的最小路径和
        return triangle[0][0];  // 返回到达顶点的最小路径和
    }
};

Best Time to Buy and Sell Stock With Transaction Fee

Tue, 07 Jan 2025 00:00:00 +0000

714. 买卖股票的最佳时机含手续费

分析

状态定义
- 定义 f[i][0] ：表示第 i 天结束时，手中没有持有股票的最大利润
- 定义 f[i][1] ：表示第 i 天结束时，手中持有股票的最大利润
状态转移
- 在第 i 天，可以有以下两种状态转移：
- 手中没有股票：
  - 可能来自前一天也没有股票，即 f[i-1][0]
  - 或者今天卖出股票，产生利润 f[i-1][1] + prices[i-1] - fee（卖出价格减去手续费）。
  - 转移公式：f[i][0] = max(f[i-1][0], f[i-1][1] + prices[i-1] - fee)
- 手中持有股票：
  - 可能来自前一天也持有股票，即 f[i-1][1]
  - 或者今天买入股票，产生利润 f[i-1][0] - prices[i-1]
  - 转移公式：f[i][1] = max(f[i-1][1], f[i-1][0] - prices[i-1])
初始状态
- 第 0 天没有股票：f[0][0] = 0（没有任何利润）
结果
- 最后一天手中没有股票的最大利润 f[n][0]

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int maxProfit(vector<int>& prices, int fee)
    {
        int n = prices.size(), INF = 0x3f3f3f3f;
        // 动态规划数组，初始化为负无穷（表示无效状态）
        std::vector<std::vector<int>> f(n + 1, std::vector<int>(2, -INF));
        f[0][0] = 0; // 第 0 天未持有股票的利润为 0
        int res = 0; // 最大利润

        for (int i = 1; i <= n; ++i)
        {
            // 第 i 天未持有股票的最大利润
            f[i][0] = std::max(f[i - 1][0], f[i - 1][1] + prices[i - 1] - fee);
            // 第 i 天持有股票的最大利润
            f[i][1] = std::max(f[i - 1][1], f[i - 1][0] - prices[i - 1]);
            // 更新最大利润
            res = std::max(res, f[i][0]);
        }
        return res;
    }
};

Domino And Tromino Tiling

Tue, 07 Jan 2025 00:00:00 +0000

790. 多米诺和托米诺平铺

分析

状态表示：
- 用 f[i][j] 表示覆盖 2 * i 面板且第i列状态为 j 的方法数。这里的状态 j 表示第 i 列的覆盖情况，具体含义如下：
  - j = 0 ：第 i 列已完全覆盖
  - j = 1 ：第 i 列的上方未覆盖，下方已覆盖
  - j = 2 ：第 i 列的下方未覆盖，上方已覆盖
  - j = 3 ：第 i 列完全未覆盖
状态转移：
- 从第 i-1 列的状态 j 转移到第 i 列的状态 k 。需要考虑瓷砖的放置规则，以及状态变化的可行性
- 定义 w[j][k] 为从状态 j 转移到状态 k 的合法性：
  - w[j][k] = 1 ：表示可以从 j 转移到 k
  - w[j][k] = 0 ：表示不可以从 j 转移到 k
初始状态：
- f[0][0] = 1 ：初始时第 0 列完全覆盖
- 其他状态初始化为 0。
目标：
- 返回 f[n][0]，即第 n 列完全覆盖的方案数

时间复杂度

外层遍历列数 n ，内层枚举状态 j 和 k 各为常数 4 ，因此时间复杂度为 O(16n) = O(n)

空间复杂度

O(n)

C++代码

class Solution
{
public:
    int numTilings(int n)
    {
        const int MOD = 1e9 + 7;

        // 转移矩阵，定义状态转移规则
        int w[4][4] = {
            {1, 1, 1, 1},
            {0, 0, 1, 1},
            {0, 1, 0, 1},
            {1, 0, 0, 0}
        };

        // 动态规划数组，f[i][j] 表示覆盖到第 i 列状态为 j 的方法数
        vector<vector<int>> f(n + 1, vector<int>(4));

        // 初始状态：第 0 列完全覆盖
        f[0][0] = 1;

        // 动态规划求解
        for (int i = 0; i < n; i++)
            for (int j = 0; j < 4; j++)
                for (int k = 0; k < 4; k++)
                    // 如果状态 j 可以转移到状态 k，则更新 f[i+1][k]
                    f[i + 1][k] = (f[i + 1][k] + f[i][j] * w[j][k]) % MOD;

        // 返回最终结果：覆盖到第 n 列且状态为 0 的方法数
        return f[n][0];
    }
};

Min Cost Climbing Stairs

Mon, 06 Jan 2025 00:00:00 +0000

746. 使用最小花费爬楼梯

分析

状态定义：
- 定义 f[i] 为到达第 i 个台阶的最低花费
状态转移：
- 每次可以从前一个台阶爬上来，也可以从前两个台阶爬上来，选择花费较小的一种：f[i] = min(f[i-1] + cost[i-1], f[i-2] + cost[i-2])
初始状态：
- f[0] = 0 ：第 0 台阶为起点，不需要任何花费
- f[1] = 0 ：第 1 台阶为起点，也不需要任何花费
目标：
- 返回 f[n] ，即爬到楼梯顶部的最小花费

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int minCostClimbingStairs(vector<int>& cost)
    {
        int n = cost.size();
        std::vector<int> f(n + 1); // DP 数组，大小为 n+1

        // 从第 2 个台阶开始计算最低花费
        for (int i = 2; i <= n; ++i)
            f[i] = std::min(f[i - 1] + cost[i - 1], f[i - 2] + cost[i - 2]);

        return f[n]; // 返回到达顶部的最小花费
    }
};

Edit Distance

Fri, 13 Dec 2024 00:00:00 +0000

72. 编辑距离

分析

状态定义
- 设 f[i][j] 表示将 word1 的前 i 个字符转换为 word2 的前 j 个字符所需的最少操作数。
状态转移
- 如果 word1[i] == word2[j]：不需要额外操作，状态继承自子问题：f[i][j] = f[i-1][j-1]
- 如果 word1[i] != word2[j]：需要进行操作，从以下三种操作中选择代价最小的一种：f[i][j] = min(f[i-1][j-1] + 1, f[i-1][j] + 1, f[i][j-1] + 1)
  - 替换：f[i-1][j-1] + 1
  - 删除：f[i-1][j] + 1
  - 插入：f[i][j-1] + 1
边界条件
- f[i][0] = i: 将 word1 的前 i 个字符转换为空字符串，需要删除 i 次
- f[0][j] = j: 将空字符串转换为 word2 的前 j 个字符，需要插入 j 次
初始化输入：
- 在代码中通过向 word1 和 word2 开头添加空格，统一了状态的表示
最终结果：
- 返回 f[n][m]，其中 n 是 word1 的长度， m 是 word2 的长度

时间复杂度

外层循环遍历 n，内层循环遍历 m，总时间复杂度为 O(nm)

空间复杂度

空间复杂度为 O(nm)

C++代码

class Solution
{
public:
    int minDistance(string word1, string word2)
    {
        // 在字符串开头添加空格，便于边界处理
        word1 = " " + word1;
        word2 = " " + word2;
        int n = word1.size(), m = word2.size();

        std::vector<std::vector<int>> f(n, std::vector<int>(m));

        // 初始化边界条件
        for (int i = 0; i < n; ++i)
            f[i][0] = i;
        for (int j = 0; j < m; ++j)
            f[0][j] = j;

        for (int i = 1; i < n; ++i)
            for (int j = 1; j < m; ++j)
            {
                // 删除、插入、替换操作的最优选择
                f[i][j] = std::min(f[i - 1][j] + 1, f[i][j - 1] + 1);
                if (word1[i] == word2[j])
                    f[i][j] = std::min(f[i][j], f[i - 1][j - 1]);
                else
                    f[i][j] = std::min(f[i][j], f[i - 1][j - 1] + 1);
            }

        // 返回结果
        return f[n - 1][m - 1];
    }
};

Longest Common Subsequence

Fri, 13 Dec 2024 00:00:00 +0000

1143. 最长公共子序列

分析

定义状态：
- f[i][j] 表示字符串 text1 的前 i 个字符与 text2 的前 j 个字符的最长公共子序列的长度
状态转移：
- 当 text1[i-1] == text2[j-1]，当前字符匹配，可以延续公共子序列的长度：f[i][j] = f[i-1][j-1] + 1
- 当 text1[i-1] != text2[j-1]，当前字符不匹配，最长公共子序列取决于舍弃其中一个字符的结果：f[i][j] = \max(f[i-1][j], f[i][j-1])
边界条件：
- f[i][0] = 0 和 f[0][j] = 0，表示任意一个字符串与空字符串的最长公共子序列长度为 0
结果：
- 最终结果存储在 f[n][m]，其中 n 和 m 分别是 text1 和 text2 的长度

时间复杂度

外层循环遍历 n，内层循环遍历 m ，时间复杂度为 O(nm)

空间复杂度

空间复杂度为 O(nm)

C++代码

class Solution
{
public:
    int longestCommonSubsequence(string text1, string text2)
    {
        int n = text1.size(), m = text2.size();
        std::vector<std::vector<int>> f(n + 1, std::vector<int>(m + 1));

        // 遍历每个字符的组合
        for (int i = 1; i <= n; ++i)
            for (int j = 1; j <= m; ++j)
            {
                f[i][j] = std::max(f[i][j - 1], f[i - 1][j]);
                // 两个字符匹配时
                if (text1[i - 1] == text2[j - 1])
                    f[i][j] = std::max(f[i][j], f[i - 1][j - 1] + 1);
            }

        // 返回最终结果
        return f[n][m];
    }
};

Minimum Path Sum

Thu, 12 Dec 2024 00:00:00 +0000

64. 最小路径和

分析

状态定义：
- 用 f[i][j] 表示从起点 (0, 0) 到达位置 (i, j) 的路径数字总和的最小值
状态转移：
- 如果机器人可以从上方或左方到达 (i, j)，则：f[i][j] = min(f[i-1][j], f[i][j-1]) + grid[i][j]
- 边界情况：
  - 如果位于第一行，则只能从左侧到达：f[0][j] = f[0][j-1] + grid[0][j]
  - 如果位于第一列，则只能从上方到达：f[i][0] = f[i-1][0] + grid[i][0]
初始条件：
- 起点 (0, 0) 的路径和等于网格的初始值：f[0][0] = grid[0][0]

时间复杂度

动态规划遍历整个网格，每个位置只需计算一次，时间复杂度为 O(mn)

空间复杂度

空间复杂度为 O(mn)

C++代码

class Solution
{
public:
    int minPathSum(vector<vector<int>>& grid)
    {
        // 获取网格的行数和列数
        int n = grid.size();
        if (n == 0)
            return 0; // 如果网格为空，直接返回 0
        int m = grid[0].size();

        // 初始化动态规划数组，所有值初始为 INT_MAX
        std::vector<std::vector<int>> f(n, std::vector<int>(m, INT_MAX));

        // 动态规划计算每个位置的最小路径和
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < m; ++j)
            {
                if (i == 0 && j == 0)
                    // 起点
                    f[i][j] = grid[i][j];
                else
                {
                    // 从上方到达
                    if (i)
                        f[i][j] = std::min(f[i][j], f[i - 1][j] + grid[i][j]);
                    // 从左方到达
                    if (j)
                        f[i][j] = std::min(f[i][j], f[i][j - 1] + grid[i][j]);
                }
            }
        }

        // 返回右下角的最小路径和
        return f[n - 1][m - 1];
    }
};

Partition Equal Subset Sum

Thu, 12 Dec 2024 00:00:00 +0000

416. 分割等和子集

分析

典型的 01 背包问题，我们需要判断是否存在一个子集，其元素和为 sum / 2，其中 sum 是数组 nums 的元素总和

特殊情况处理：
- 如果数组总和 sum 是奇数，则无法分成两个相等的子集，直接返回 false
动态规划定义：
- 定义一个布尔数组 f，其中 f[j] 表示是否可以从数组中选取一些元素，使得这些元素的和为 j
- 初始化 f[0] = true，表示总和为 0 的情况总是成立（即不选任何元素）
状态转移方程：
- 遍历数组 nums 中的每个数 nums[i]，从目标值 target 开始往下更新：
  - f[j] = f[j] || f[j - nums[i]]
- 表示如果在之前能凑出 j - nums[i]，则加入当前数字后也能凑出 j
最终结果：
- 如果能凑出目标值 sum / 2，即 f[target] == true，则可以分成两个相等的子集

时间复杂度

外层循环遍历数组 n 次
内层循环遍历目标值 target 次

总时间复杂度 O(n * target)

空间复杂度

空间复杂度为 O(target)

C++代码

class Solution
{
public:
    bool canPartition(vector<int>& nums)
    {
        int sum = 0;
        for (int num : nums)  // 计算数组的总和
            sum += num;

        if (sum % 2)  // 如果总和是奇数，无法分割成两个相等的子集
            return false;

        int target = sum / 2;  // 目标子集的和
        int n = nums.size();
        std::vector<bool> f(target + 1, false);  // 定义状态数组，f[j] 表示是否可以凑出总和 j
        f[0] = true;  // 总和为 0 的情况成立

        for (int i = 0; i < n; ++i)  // 遍历每个数
            for (int j = target; j >= nums[i]; --j)  // 从 target 向下遍历，避免状态覆盖
                f[j] = f[j] || f[j - nums[i]];

        return f[target];  // 返回是否可以凑出目标总和
    }
};

Unique Paths

Thu, 12 Dec 2024 00:00:00 +0000

62. 不同路径

分析

状态定义：
- 用 f[i][j] 表示从起点 (0, 0) 到达网格位置 (i, j) 的不同路径数
状态转移：
- 如果机器人能够从上方或左方到达 (i, j)：
  - 从上方到达：路径数为 f[i-1][j]
  - 从左方到达：路径数为 f[i][j-1]
- 因此，状态转移方程为：f[i][j] = f[i-1][j] + f[i][j-1]
初始条件：
- 起点 (0, 0) 的路径数为 1，即 f[0][0] = 1
- 第一行和第一列的位置只能从一个方向到达：
  - 第一行：只能从左到右
  - 第一列：只能从上到下

时间复杂度

需要遍历整个网格，时间复杂度为 O(mn)

空间复杂度

空间复杂度为 O(mn)

C++代码

class Solution
{
public:
    int uniquePaths(int m, int n)
    {
        // 创建一个二维数组 f，用于记录每个位置的路径数
        std::vector<std::vector<int>> f(n, std::vector<int>(m));

        // 遍历每个位置
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < m; ++j)
            {
                // 初始化起点
                if (i == 0 && j == 0)
                    f[i][j] = 1;
                else
                {
                    // 从上方到达
                    if (i)
                        f[i][j] += f[i - 1][j];
                    // 从左方到达
                    if (j)
                        f[i][j] += f[i][j - 1];
                }
            }
        }
        // 返回终点的路径数
        return f[n - 1][m - 1];
    }
};

Coin Change

Wed, 11 Dec 2024 00:00:00 +0000

322. 零钱兑换

分析

定义状态：
- f[j]：表示凑成金额 j 所需的最少硬币个数
状态转移方程：
- 对于每个硬币面值 coins[i]，如果选择该硬币，那么金额 j 的状态可以由金额 j - coins[i] 转移而来：f[j] = min(f[j], f[j - coins[i]] + 1)，即当前金额的最优解为不选择当前硬币的解和选择当前硬币的解的较小值
初始化：
- f[0] = 0：凑成金额 0 所需的硬币数为 0
- 其他状态 f[j] 初始化为无穷大（设为一个较大的值 INF），表示尚未凑成
结果判断：
- 如果 f[amount] = INF ，表示无法凑成金额 amount，返回 -1
- 否则返回 f[amount]

时间复杂度

外层循环遍历硬币种类 O(n) ，内层循环遍历金额 O(amount) ，总复杂度为 O(n * amount)

空间复杂度

空间复杂度为 O(amount)

C++代码

class Solution
{
public:
    int coinChange(vector<int>& coins, int amount)
    {
        int INF = 0x3f3f3f3f;  // 定义一个较大的值表示无穷大
        std::vector<int> f(amount + 1, INF);  // 初始化 DP 数组
        f[0] = 0;  // 金额为 0 时需要 0 个硬币

        for (int i = 0; i < coins.size(); ++i)  // 遍历每个硬币面值
        {
            for (int j = coins[i]; j <= amount; ++j)  // 遍历所有可能金额
            {
                f[j] = std::min(f[j], f[j - coins[i]] + 1);  // 状态转移
            }
        }

        if (f[amount] == INF)  // 如果金额无法凑成
            return -1;
        return f[amount];  // 返回最优解
    }
};

Longest Increasing Subsequence

Wed, 11 Dec 2024 00:00:00 +0000

300. 最长递增子序列

分析

思路
- 使用一个数组 q 来维护当前已知的递增子序列。这个数组不一定是真实的子序列，而是用于动态记录递增子序列的长度信息
- 遍历数组 nums 时，依次将当前数字插入到 q 中，保证 q 中的元素始终满足递增条件
处理策略：
- 如果当前数字 x 大于 q 的最后一个元素，则直接追加到 q 的末尾
- 否则，使用二分查找找到 q 中第一个大于或等于 x 的位置，并用 x 替换该位置的值这相当于更新子序列，使其在同样长度的情况下更容易扩展
返回结果：
- 最终数组 q 的长度即为最长递增子序列的长度

时间复杂度

遍历数组时，每个元素需要执行一次二分查找，二分查找的复杂度为 O(logn)

总时间复杂度 O(nlogn)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int lengthOfLIS(vector<int>& nums)
    {
        std::vector<int> q;  // 用于记录递增子序列的数组
        for (int x : nums)
        {
            if (q.empty() || x > q.back())  // 如果当前数字大于子序列末尾元素
                q.push_back(x);  // 直接追加
            else
            {
                // 使用二分查找定位
                int l = 0, r = q.size() - 1;
                while (l < r)
                {
                    int mid = (l + r) >> 1;  // 中间位置
                    if (x <= q[mid])  // 如果当前数字小于等于 q[mid]
                        r = mid;  // 缩小右边界
                    else
                        l = mid + 1;  // 缩小左边界
                }
                q[r] = x;  // 替换第一个大于等于 x 的位置
            }
        }
        return q.size();  // q 的长度即为最长递增子序列的长度
    }
};

Word Break

Wed, 11 Dec 2024 00:00:00 +0000

139. 单词拆分

分析

状态定义：
- 定义 f[i]：表示从第 i 个字符到字符串结尾的子串能否被字典中的单词拼接而成
状态转移：
- 对于子串 s[i:j]，若 s[i:j] 出现在字典中，且 f[j] = true，则可以拼接出 s[i:n]，即 f[i] = true
初始化：
- f[n] = true：空字符串可以被成功拼接
结果：
- 返回 f[0]，即判断整个字符串是否可以被拼接

时间复杂度

外层循环遍历字符串 O(n) ，内层循环遍历每个子串的结尾 O(n) ，检查子串是否在字典中平均耗时 O(k) ，其中 k 是子串的平均长度

总时间复杂度为 O(n^2 * k)

空间复杂度

动态规划数组 f 占用 O(n)
哈希表占用 O(l) ，其中 l 是字典中单词的总长度

总空间复杂度为 O(n + l)

C++代码

class Solution
{
public:
    bool wordBreak(string s, vector<string>& wordDict)
    {
        std::unordered_set<std::string> hash;  // 使用哈希表存储字典中的单词
        for (std::string word : wordDict)
            hash.insert(word);

        int n = s.size();
        std::vector<bool> f(n + 1, false);  // 动态规划数组
        f[n] = true;  // 初始化空字符串为可拼接

        // 从后向前遍历字符串
        for (int i = n - 1; i >= 0; --i)
        {
            std::string str;  // 记录当前子串
            for (int j = i; j < n; ++j)
            {
                str += s[j];  // 扩展子串
                if (hash.count(str) && f[j + 1])  // 检查是否满足条件
                {
                    f[i] = true;
                    break;
                }
            }
        }

        return f[0];  // 返回结果
    }
};

Climbing Stairs

Tue, 10 Dec 2024 00:00:00 +0000

70. 爬楼梯

分析

典型的斐波那契数列问题。到达第 n 阶的方法数等于到达第 n-1 阶和第 n-2 阶的方法数之和状态转移方程：f(n) = f(n-1) + f(n-2)

初始条件：

f(0) = 1 ：到达第 1 阶的方法只有一种
f(1) = 1 ：到达第 1 阶的方法只有一种
f(2) = 2 ：到达第 2 阶的方法是两种 1 + 1

通过观察状态转移公式，问题可以转化为计算斐波那契数列的第 n 项
使用两个变量来存储状态值，优化空间复杂度：
- a ：表示到达前一阶的方法数
- b ：表示到达当前阶的方法数
迭代更新 a 和 b 的值，直到计算到第 n 阶

时间复杂度

循环执行 n - 1 次，时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int climbStairs(int n)
    {
        int a = 1, b = 1;   // 初始状态：f(0) = 1, f(1) = 1
        while ( -- n)       // 从第 2 阶开始计算
        {
            int c = a + b;  // 当前阶方法数等于前两阶之和
            a = b;          // 更新前一阶为当前阶
            b = c;          // 更新当前阶为下一阶
        }
        return b;           // 返回第 n 阶的方法数
    }
};

House Robber

Tue, 10 Dec 2024 00:00:00 +0000

198. 打家劫舍

分析

定义状态：
- f[i]：表示偷取第 i 个房屋的最高金额
- g[i]：表示不偷取第 i 个房屋的最高金额
状态转移方程：
- 若偷第 i 个房屋：f[i] = g[i - 1] + nums[i - 1]，即前一个房屋没有被偷，当前房屋可以偷取，累加其金额。
- 若不偷第 i 个房屋：g[i] = max(f[i - 1], g[i - 1])，即第 i 个房屋不被偷，其最优结果取决于前一个房屋偷或不偷的最大值
初始化：
- f[0] = 0（没有房屋可偷）
- g[0] = 0 （没有房屋可偷）
结果：
- 最终的最大金额为：max(f[n], g[n])

时间复杂度

遍历一次数组，时间复杂度为 O(n)

空间复杂度

使用两个长度为 n + 1 的数组，空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int rob(vector<int>& nums)
    {
        int n = nums.size();
        std::vector<int> f(n + 1), g(n + 1);  // 定义偷和不偷的状态数组

        for (int i = 1; i <= n; ++ i)
        {
            f[i] = g[i - 1] + nums[i - 1];  // 偷当前房屋
            g[i] = std::max(f[i - 1], g[i - 1]);  // 不偷当前房屋
        }

        return std::max(f[n], g[n]);  // 返回最大值
    }
};

Pascals Triangle

Tue, 10 Dec 2024 00:00:00 +0000

118. 杨辉三角

分析

杨辉三角的特点是：

第 i 行有 i 个元素
每行的首尾元素为 1
中间的每个元素为其上一行相邻两个元素的和

公式：f[i][j] = f[i-1][j-1] + f[i-1][j]

初始化数据结构：
- 使用一个二维数组 f 存储结果
逐行构造杨辉三角：
- 第 i 行初始化一个大小为 i + 1 的数组
- 设置首尾元素为 1
- 遍历中间位置，根据公式计算值并填充
返回结果：
- 将每一行加入结果数组并返

时间复杂度

外层循环运行 n 次；
内层循环最多运行 n - 2 次

总体复杂度为：O(1 + 2 + 3 + ... + n) = O(n^2)

空间复杂度

空间复杂度为 O(n^2)

C++代码

class Solution
{
public:
    vector<vector<int>> generate(int numRows)
    {
        std::vector<std::vector<int>> f;
        for (int i = 0; i < numRows; ++ i)  // 遍历每一行
        {
            std::vector<int> line(i + 1);  // 初始化当前行，长度为 i+1
            line[0] = line[i] = 1;         // 每行的首尾元素为 1

            for (int j = 1; j < i; ++ j)   // 中间元素由上一行相邻元素之和计算得出
                line[j] = f[i - 1][j - 1] + f[i - 1][j];

            f.push_back(line);             // 将当前行加入结果数组
        }
        return f;
    }
};

Perfect Squares

Tue, 10 Dec 2024 00:00:00 +0000

279. 完全平方数

分析

定义状态：
- f[i] ：表示和为 i 的完全平方数的最少数量
状态转移方程：
- 对于 i ，尝试减去一个完全平方数 j^2 ，转移状态为：f[i] = min(f[i], f[i - j^2] + 1)
初始化：
- f[0] = 0 ：和为 0 的最少数量为 0
- 其他状态 f[i] 初始化为 4，因为根据四平方和定理，一个数至多由 4 个完全平方数组成
遍历顺序：
- 外层循环遍历 i（目标和），内层循环遍历 j（尝试的完全平方数）
结果：
- 返回 f[n] 即为和为 n 的完全平方数的最少数量

时间复杂度

外层循环遍历 i 从 1 到 n，内层循环枚举完全平方数的数量，最多为 \sqrt{n}

总复杂度为 O(n*\sqrt{n})

空间复杂度

使用排序 O(logn) 的额外空间，其余操作在原地完成，空间复杂度为 O(1)

使用了长度为 n + 1 的数组 f，空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int numSquares(int n)
    {
        std::vector<int> f(n + 1, 4);  // 初始化 f 数组，最大值为 4
        f[0] = 0;  // 和为 0 时的最少数量为 0

        for (int i = 1; i <= n; ++i)
        {
            for (int j = 1; j * j <= i; ++j)
            {
                f[i] = std::min(f[i], f[i - j * j] + 1);  // 状态转移
            }
        }

        return f[n];  // 返回结果
    }
};

Push Dominoes

Sat, 07 Dec 2024 00:00:00 +0000

838. 推多米诺

分析

字符串首尾哨兵添加：
- 为简化边界条件处理，在字符串首部添加 'L'，尾部添加 'R'，变成 dominoes = 'L' + dominoes + 'R'
- 这样首尾骨牌始终有确定的受力方向
预处理左右最近的受力源：
- 定义两个数组 l 和 r：
  - l[i] 表示索引 i 左侧最近的 'L' 的位置；
  - r[i] 表示索引 i 右侧最近的 'R' 的位置
- 遍历计算：
  - 从左向右遍历填充 l，记录每个位置最近的 'L'；
  - 从右向左遍历填充 r，记录每个位置最近的 'R'
根据受力平衡更新状态：
- 遍历每个位置，根据 l[i] 和 r[i] 的值判断受力方向：
  - 如果 dominoes[l[i]] == 'L' && dominoes[r[i]] == 'R'，受力平衡，骨牌保持竖立 '.'；
  - 如果两侧的受力方向一致，骨牌倒向对应方向；
  - 如果受力方向不同且距离不同，骨牌倒向距离近的一侧；
  - 如果受力方向不同且距离相等，骨牌保持竖立 '.'
移除哨兵：
- 返回字符串 dominoes.substr(1, n - 2)，移除首尾哨兵

时间复杂度

遍历三次字符串：分别计算 l 和 r 的值，以及最终更新 dominoes 的状态

总时间复杂度 O(n)

空间复杂度

空间复杂度：O(n)

C++代码

class Solution
{
public:
    string pushDominoes(string dominoes)
    {
      // 添加哨兵
      dominoes = 'L' + dominoes + 'R';
      int n = dominoes.size();
      std::vector<int> l(n), r(n);

      // 记录左侧最近的'L'
      int pos = 0;
      for (int i = 1; i < n; ++i)
      {
        if (dominoes[i] != '.')
          pos = i; // 更新最近的'L'或'R'
        l[i] = pos; // 保存当前位置左侧的最近受力源
      }

      // 记录右侧最近的'R'
      for (int i = n - 1; i >= 0; --i)
      {
        if (dominoes[i] != '.')
          pos = i; // 更新最近的'L'或'R'
        r[i] = pos; // 保存当前位置右侧的最近受力源
      }

      // 判断骨牌最终的状态
      for (int i = 0; i < n; ++i)
      {
        if (dominoes[l[i]] == 'L' && dominoes[r[i]] == 'R')
        {
          dominoes[i] = '.'; // 平衡受力
        }
        else if (dominoes[l[i]] == 'L' && dominoes[r[i]] == 'L')
        {
          dominoes[i] = 'L'; // 受左侧'L'影响
        }
        else if (dominoes[l[i]] == 'R' && dominoes[r[i]] == 'R')
        {
          dominoes[i] = 'R'; // 受右侧'R'影响
        }
        else
        {
          // 受不同方向影响，根据距离判断
          if (i - l[i] < r[i] - i)
            dominoes[i] = 'R';
          else if (i - l[i] > r[i] - i)
            dominoes[i] = 'L';
          else
            dominoes[i] = '.';
        }
      }

      // 移除首尾哨兵
      return dominoes.substr(1, n - 2);
    }
};

Palindrome Partitioning

Thu, 05 Dec 2024 00:00:00 +0000

131. 分割回文串

分析

预处理判断回文子串：
- 通过动态规划预处理所有可能的子串，判断每个子串是否是回文
- 定义二维数组 f[i][j]，表示从 i 到 j 的子串是否为回文：
  - 若 s[i] == s[j]，且内部的子串 s[i+1:j-1] 也是回文，则 f[i][j] = true
  - 特殊情况下（i == j 或 j == i+1），直接判断字符是否相等
回溯搜索分割方案：
- 从字符串的第一个字符开始尝试分割
- 若当前子串是回文，则将其加入路径中，继续搜索剩余部分
- 如果遍历完整个字符串，将当前路径保存为一种结果
- 搜索结束后，将最后加入路径的子串弹出，回溯到上一步继续尝试

时间复杂度

预处理回文数组：需要枚举所有子串，时间复杂度为 O(n²)
回溯搜索：每个字符有两种选择（分割或不分割），复杂度近似为 O(2ⁿ)

总体时间复杂度：O(n² + 2ⁿ)

空间复杂度

动态规划数组 f 占用 O(n²)
递归深度最多为字符串长度 n，路径数组和递归栈占用 O(n)

总体空间复杂度：O(n²)

C++代码

class Solution
{
public:
    std::vector<std::vector<std::string>> res; // 存储最终结果
    std::vector<std::string> path; // 当前路径
    std::vector<std::vector<bool>> f; // 动态规划存储回文判断结果

    vector<vector<string>> partition(string s)
    {
      int n = s.size();
      // 初始化回文判断数组
      f = std::vector<std::vector<bool>>(n, std::vector<bool>(n));

      // 动态规划预处理回文子串
      for (int j = 0; j < n; ++j)
        for (int i = 0; i <= j; ++i)
        {
          if (i == j) // 单个字符是回文
            f[i][j] = true;
          else if (s[i] == s[j]) // 判断两端字符是否相等
            if (i + 1 > j - 1 || f[i + 1][j - 1]) // 内部子串为空或回文
              f[i][j] = true;
        }

      // 开始回溯搜索
      dfs(s, 0);
      return res;
    }

    void dfs(std::string s, int u)
    {
      // 如果已经分割到字符串末尾，保存当前路径
      if (u == s.size())
      {
        res.push_back(path);
        return;
      }

      // 遍历从 u 开始的每个子串
      for (int i = u; i < s.size(); ++i)
        if (f[u][i]) // 如果当前子串是回文
        {
          path.push_back(s.substr(u, i - u + 1)); // 加入路径
          dfs(s, i + 1); // 递归处理剩余部分
          path.pop_back(); // 回溯
        }
    }
};

maxSubArray

Wed, 27 Nov 2024 00:00:00 +0000

53. 最大子数组和

算法

定义状态：
- 用变量 last 表示以当前元素结尾的最大子数组和
- 用变量 res 表示全局最大子数组和
状态转移方程：
- 对于每个元素 num，当前的 last 值可以由以下两种情况决定：
  - 单独包含当前元素：如果此前的 last 为负数，则舍弃
  - 包含当前元素并延续之前的子数组：如果此前的 last 为正数，则将当前元素加入子数组
- 状态转移方程：last = max(num, last + num)
更新全局最大值：
- 在遍历每个元素后，更新全局最大值 res 为：res = max(res, last)

复杂度分析

时间复杂度

单次遍历：仅需遍历数组一次，时间复杂度为 O(n)

空间复杂度

只使用了 res 和 last 两个变量，空间复杂度为 O(1)

C++ 代码

class Solution
{
public:
    int maxSubArray(vector<int>& nums)
    {
        int res = INT_MIN; // 全局最大子数组和
        int last = 0;      // 当前子数组和
        for (int num : nums)
        {
            last = std::max(num, last + num); // 动态更新以当前元素结尾的最大子数组和
            res = std::max(res, last);       // 更新全局最大值
        }
        return res;
    }
};

Python 代码

class Solution:
  def maxSubArray(self, nums: List[int]) -> int:
    res, last = nums[0], 0
    for x in nums:
      last = max(x, last + x)
      res = max(res, last)
    return res

Go 代码

func maxSubArray(nums []int) int {
  res, last := nums[0], 0
  for _, x := range nums {
    last = max(x, last + x)
    res = max(res, last)
  }
  return res
}

JavaScript 代码

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function (nums) {
  let res = nums[0],
    last = 0;
  for (let x of nums) {
    last = Math.max(x, last + x);
    res = Math.max(res, last);
  }
  return res;
};