动态规划算法之最长递增子序列

动态规划的思想来解决最长递增子序列（Longest Increasing Subsequence，LIS问题。动态规划的核心思想是将一个复杂的问题分解成更简单的子问题，并通过解决子问题来构建原问题的解。

在这个例子中，使用动态规划的方式计算了以每个元素结尾的最长递增子序列的长度，然后通过比较这些长度找到最终的最长递增子序列的长度。这种方法避免了指数级的递归计算，提高了算法的效率。

#include <iostream>
#include <vector>

std::vector<int> longestIncreasingSubsequence(const std::vector<int>& nums, int &maxLength) {
    int n = nums.size();
    if (n == 0) {
        return {};
    }

    std::vector<int> dp(n, 1);  // dp[i] 表示以 nums[i] 结尾的最长递增子序列的长度
    std::vector<int> prevIndex(n, -1);
    // 这两行定义了两个整数向量 dp 和 prevIndex，长度都为 n。dp[i] 表示以 nums[i] 结尾的最长递增子序列的长度，prevIndex[i] 存储在以 nums[i] 结尾的子序列中，nums[i] 的前一个元素的索引。
    for (int i = 1; i < n; ++i) {
        for (int j = 0; j < i; ++j) {
            if (nums[i] > nums[j] && dp[i] < dp[j] + 1) {
                dp[i] = dp[j] + 1;
                prevIndex[i] = j;
            }
        }
    }
    // 这两个嵌套的 for 循环用于遍历所有可能的子序列。在内层循环中，如果 nums[i] 大于 nums[j] 且 dp[i] 小于 dp[j] + 1，则表示可以将 nums[i] 加入到以 nums[j] 结尾的递增子序列中，此时更新 dp[i] 为 dp[j] + 1，并记录 prevIndex[i]。
    int endIndex = 0;
    for (int i = 1; i < n; ++i) {
        if (dp[i] > maxLength) {
            maxLength = dp[i];
            endIndex = i;
        }
    }
    // 这几行用于找到整个数组的最长递增子序列的长度以及其结束位置。
    std::vector<int> result;
    while (endIndex != -1) {
        result.insert(result.begin(), nums[endIndex]);
        endIndex = prevIndex[endIndex];
    }
    // 这几行通过回溯 prevIndex 数组，构建最长递增子序列的具体元素，并保存在 result 中。
    return result;
    // 返回结果
}

int main() {
    int maxLength = 1;

    std::vector<int> nums = {10, 22, 9, 33, 21, 50, 41, 60, 80, 9, 90};

    std::vector<int> result = longestIncreasingSubsequence(nums, maxLength);
    std::cout << "Longest Increasing Subsequence: ";
    for (int num : result) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    std::cout << "maxLength = "<< maxLength << std::endl;

    return 0;
}