动态规划：子序列系列及其扩展

最新推荐文章于 2024-07-25 10:54:19 发布
最新推荐文章于 2024-07-25 10:54:19 发布
阅读量110 收藏
点赞数
分类专栏： 算法题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44781747/article/details/115283908
版权
本文探讨了动态规划在解决数组和字符串问题中的应用，包括最长递增子序列、最长连续递增子数组、最长公共子序列、最长回文子序列以及编辑距离。通过对各种问题的思路分析，展示了动态规划状态转移方程的建立和初始状态的设定，以及如何自底向上计算最优解。同时，文章还讨论了空间优化的可能性。
摘要由CSDN通过智能技术生成

LeetCode300. 最长递增子序列

https://leetcode-cn.com/problems/longest-increasing-subsequence/

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
思路

1.思考状态：找出最优解的性质，明确状态表示什么

dp[i]表示数组nums[0 … i]的最长递增子序列的长度。

2.思考状态转移方程：大问题的最有解如何由小问题的最优解得到

位置i的最长递增子序列等于j从0到i-1各个位置的最长递增子序列 + 1 的最大值。

所以：if (nums[i] > nums[j]): dp[i] = max(dp[j] + 1)，其中0 <= j <= i - 1

3.思考初始状态

每一个位置i，对应的dp[i]（即最长递增子序列）起始大小至少都是是1.

所以：dp[i] = 1

4.自底向上计算得到最优解

dp[i] 是有0到i-1各个位置的最长递增子序列推导而来，那么遍历i一定是从前向后遍历。

即：

int result = 1;
for (int i = 1; i < size; ++i)
{
    for (int j = 0; j < i; ++j)
    {
        if (nums[i] > nums[j])
        {
            dp[i] = max(dp[i], dp[j] + 1);
        }
    }
    result = max(result, dp[i]);  
}

5.思考是否可以进行空间的优化

代码
class Solution 
{
public:
    int lengthOfLIS(vector<int>& nums) 
    {
        int size = nums.size();
        if (size == 0) return 0;

        vector<int> dp(size, 1);
        int result = 1;
        for (int i = 1; i < size; ++i)
        {
            for (int j = 0; j < i; ++j)
            {
                if (nums[i] > nums[j])
                {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            result = max(result, dp[i]);  
        }

        return result;
    }
};

LeetCode674. 最长递增子数组

https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence/

给定一个未经排序的整数数组，找到最长递增子数组，并返回该序列的长度。

输入：nums = [1,3,5,4,7]
输出：3
解释：最长递增子数组是 [1,3,5], 长度为3。

思路

1.思考状态：找出最优解的性质，明确状态表示什么

以下标i为结尾的数组的连续递增的子序列长度为dp[i]。

注意这里的定义，一定是以下标i为结尾，并不是说一定以下标0为起始位置。

2.思考状态转移方程：大问题的最有解如何由小问题的最优解得到

如果 nums[i] > nums[i - 1]，那么以 i 为结尾的数组的连续递增的子序列长度 一定等于 以 i - 1 为结尾的数组的连续递增的子序列长度 + 1 。

所以：if (nums[i] > nums[i - 1]): dp[i] = dp[i - 1] + 1

注意这里就体现出和LeetCode300. 最长递增子序列的区别!

因为本题要求连续递增子序列，所以就必要比较nums[i]与nums[i - 1]，而不用去比较nums[i]与nums[j] （j是在0到i - 1之间遍历）。

既然不用j了，那么也不用两层for循环，本题一层for循环就行，比较nums[i] 和 nums[i - 1]。

3.思考初始状态

以下标i为结尾的数组的最递增子数组长度最少也应该是1，即就是nums[i]这一个元素。

所以：dp[i] = 1

4.自底向上计算得到最优解

dp[i + 1]依赖dp[i]，所以一定是从前向后遍历。

int result = 1;
for (int i = 1; i < sz; ++i)
{
    if (nums[i] > nums[i - 1])
    {
        dp[i] = dp[i - 1] + 1;
    }
    result = max(result, dp[i]);
}

5.思考是否可以进行空间的优化

代码
class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) 
    {
        int sz = nums.size();
        if (sz == 0) return 0;

        vector<int> dp(sz, 1);
        int result = 1;
        for (int i = 1; i < sz; ++i)
        {
            if (nums[i] > nums[i - 1])
            {
                dp[i] = dp[i - 1] + 1;
            }
            result = max(result, dp[i]);
        }

        return result;
    }
};

LeetCode1143. 最长公共子序列

https://leetcode-cn.com/problems/longest-common-subsequence/

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。若这两个字符串没有公共子序列，则返回 0。

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace"，它的长度为 3。
思路

1.思考状态：找出最优解的性质，明确状态表示什么

dp[i] [j]表示长度为i的字符串text1和长度为j的字符串text2的最长公共子序列的长度，即[0, i - 1]的字符串text1与[0, j - 1]的字符串text2的最长公共子序列的长度

2.思考状态转移方程：大问题的最有解如何由小问题的最优解得到

主要就是两大情况：text1[i - 1] 与 text2[j - 1]相同，text1[i - 1] 与 text2[j - 1]不相同

  • 如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i] [j] = dp[i - 1] [j - 1] + 1;

  • 如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。

即：if (text1[i - 1] == text2[j - 1]): dp[i] [j] = dp[i - 1] [j - 1] + 1

​ if (text1[i - 1] != text2[j - 1]): dp[i] [j] = max(dp[i - 1] [j], dp[i] [j - 1])

3.思考初始状态

text1[0, i-1]和空串的最长公共子序列自然是0，所以dp[i] [0] = 0;

同理dp[0] [j]也是0。

即：dp[i] [0] = 0

​ dp[0] [j] = 0

4.自底向上计算得到最优解

for (int i = 1; i <= size1; ++i)
{
    for (int j = 1; j <= size2; ++j)
    {
        if (text1[i - 1] == text2[j - 1])
        {
            dp[i][j] = dp[i - 1][j - 1] + 1;
        }
        else
        {
            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
        }
    }
}

5.思考是否可以进行空间的优化

代码
class Solution 
{
public:
    int longestCommonSubsequence(string text1, string text2) 
    {
        int size1 = text1.size();
        int size2 = text2.size();

        vector<vector<int>> dp(size1 + 1, vector<int>(size2 + 1, 0));
        for (int i = 1; i <= size1; ++i)
        {
            for (int j = 1; j <= size2; ++j)
            {
                if (text1[i - 1] == text2[j - 1])
                {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                else
                {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }

        return dp[size1][size2];
    }
};

LeetCode718. 最长公共子数组

https://leetcode-cn.com/problems/maximum-length-of-repeated-subarray/

给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。

输入：
A: [1,2,3,2,1]
B: [3,2,1,4,7]
输出：3
解释：
长度最长的公共子数组是 [3, 2, 1] 。
思路

1.思考状态：找出最优解的性质，明确状态表示什么

dp[i] [j]表示以下标i - 1为结尾的整数数组A与以下标j - 1为结尾的整数数组B的最长公共子数组的长度

2.思考状态转移方程：大问题的最有解如何由小问题的最优解得到

根据dp[i] [j]的定义，dp[i] [j]的状态只能由dp[i - 1] [j - 1]推导出来。

即：if (A[i - 1] == B[i - 1]): dp[i] [j] = dp[i - 1] [j - 1] + 1;

3.思考初始状态

根据dp[i] [j]的定义，dp[i] [0] 和dp[0] [j]其实都是没有意义的！

但dp[i] [0] 和dp[0] [j]要初始值，因为为了方便递归公式dp[i] [j] = dp[i - 1] [j - 1] + 1，所以dp[i] [0] 和dp[0] [j]初始化为0。

举个例子：A[0]如果和B[0]相同的话，dp[1] [1] = dp[0] [0] + 1，只有dp[0] [0]初始为0，正好符合递推公式逐步累加起来。

4.自底向上计算得到最优解

外层for循环遍历A，内层for循环遍历B。

int result = 0;
for (int i = 1; i <= aSize; ++i)
{
    for (int j = 1; j <= bSize; ++j)
    {
        if (A[i - 1] == B[j - 1])
        {
            dp[i][j] = dp[i - 1][j - 1] + 1;
        }
    result = max(result, dp[i][j]);
    }
}

5.思考是否可以进行空间的优化

代码
class Solution 
{
public:
    int findLength(vector<int>& A, vector<int>& B) 
    {
        int aSize = A.size();
        int bSize = B.size();

        vector<vector<int>> dp(aSize + 1, vector<int>(bSize + 1, 0));
        int result = 0;
        for (int i = 1; i <= aSize; ++i)
        {
            for (int j = 1; j <= bSize; ++j)
            {
                if (A[i - 1] == B[j - 1])
                {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                result = max(result, dp[i][j]);
            }
        }

        return result;
    }
};

LeetCode516. 最长回文子序列

https://leetcode-cn.com/problems/longest-palindromic-subsequence/

给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。

输入:
"bbbab"
输出:
4
一个可能的最长回文子序列为 "bbbb"。
思路

1.思考状态：找出最优解的性质，明确状态表示什么

dp[i] [j] 表示s[i…j]的最长回文子序列的长度

2.思考状态转移方程：大问题的最有解如何由小问题的最优解得到

关键逻辑就是看s[i]与s[j]是否相同。

  • 如果s[i]与s[j]相同，那么dp[i] [j] = dp[i + 1] [j - 1] + 2;
    在这里插入图片描述

  • 如果s[i]与s[j]不相同，说明s[i]和s[j]的同时加入不能增加[i,j]区间回文子串的长度，那么分别加入s[i]、s[j]看看哪一个可以组成最长的回文子序列。

    加入s[i]的回文子序列长度为dp[i + 1] [j]。

    加入s[j]的回文子序列长度为dp[i] [j - 1]。

    那么dp[i] [j]一定是取最大的，即：dp[i] [j] = max(dp[i + 1] [j], dp[i] [j - 1]);

在这里插入图片描述

所以： if (s[i] == s[j]): dp[i] [j] = dp[i + 1] [j - 1] + 2
if (s[i] != s[j]): dp[i] [j] = max(dp[i + 1] [j], dp[i] [j - 1])

3.思考初始状态

一个字符的回文子序列长度就是1。

所以：dp[i] [i] = 1

4.自底向上计算得到最优解

从递推公式dp[i] [j] = dp[i + 1] [j - 1] + 2 和 dp[i] [j] = max(dp[i + 1] [j], dp[i] [j - 1]) 可以看出，dp[i] [j]的计算是依赖于dp[i + 1] [j - 1] 、dp[i + 1] [j]和dp[i] [j - 1]

也就是从矩阵的角度来说，dp[i] [j]的计算是依赖与下一行和前一列的数据。 所以遍历i的时候一定要从下到上遍历，遍历j的时候一定要从左到右遍历这样才能保证，下一行的数据，前一列的数据是经过计算的。

在这里插入图片描述

        for (int i = size - 1; i >= 0; --i)
        {
            for (int j = i + 1; j < size; ++j)
            {
                if (s[i] == s[j])
                {
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                }
                else
                {
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }

5.思考是否可以进行空间的优化

另一种思路

我们可以将字符串逆序得到另一个字符串，将问题转换为求原始字符串和逆序字符串的最长公共子序列，求解最长公共子序列的思路见前文：LeetCode1143. 最长公共子序列。

代码
class Solution 
{
public:
    //动态规划
    int longestPalindromeSubseq(string s) 
    {
        int size = s.size();
        if(size == 0)
        {
            return 0;
        }

        vector<vector<int>> dp(size, vector<int>(size, 0));
        for (int i = 0; i < size; ++i)
        {
            dp[i][i] = 1;
        }
        
        for (int i = size - 1; i >= 0; --i)
        {
            for (int j = i + 1; j < size; ++j)
            {
                if (s[i] == s[j])
                {
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                }
                else
                {
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }

        return dp[0][size - 1];
    }

    //转换为LCS
    /*int longestPalindromeSubseq(string s)
    {
        int size = s.size();
        if(size == 0)
        {
            return 0;
        }

        string sReverse(s);
        for (int i = 0; i < size; ++i)
        {
            sReverse[i] = s[size - i - 1];
        }

        vector<vector<int>> dp(size + 1, vector<int>(size + 1, 0));
        for (int i = 1; i <= size; ++i)
        {
            for (int j = 1; j <= size; ++j)
            {
                if (s[i - 1] == sReverse[j - 1])
                {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                else
                {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }

        return dp[size][size];
    }*/
};

LeetCode161. 相距为1的编辑距离

https://leetcode-cn.com/problems/one-edit-distance/

给定两个字符串 s 和 t，判断他们的编辑距离是否为 1。

注意：

满足编辑距离等于 1 有三种可能的情形：

  • 往 s 中插入一个字符得到 t
  • 从 s 中删除一个字符得到 t
  • 在 s 中替换一个字符得到 t
输入: s = "ab", t = "acb"
输出: true
解释: 可以将 'c' 插入字符串 s 来得到 t。

输入: s = "cab", t = "ad"
输出: false
解释: 无法通过 1 步操作使 s 变为 t。
思路

字符串s的大小为sSize，字符串t的大小为tSize，不妨假设sSize <= tSize 。

  • 如果tSize - sSize >= 2：编辑距离一定不为1
  • 如果两个字符串下标为i的字符不相等：

​ 1.如果sSize等于tSize：判断s.substr(i + 1)是否等于t.substr(i + 1)。如果

​ 相等则编辑距离为1(更新操作)；如果不相等则编辑距离不为1。

​ 2.如果sSize + 1等于tSize：判断s.substr(i )是否等于t.substr(i + 1)。如果

​ 相等则编辑距离为1(插入操作)；如果不相等则编辑距离不为1。

在这里插入图片描述

  • 如果两个字符串前sSize个字符相等：

​ 1.如果sSize等于tSize：两个字符串相等，编辑距离不为1。

​ 2.如果sSize + 1等于tSize：编辑距离为1(插入操作)

代码
class Solution 
{
public:
    bool isOneEditDistance(string s, string t) 
    {
        int sSize = s.size();
        int tSize = t.size();

        if (sSize > tSize)
        {
            return isOneEditDistance(t, s);
        }

        if ((tSize - sSize) >= 2)
        {
            return false;
        }
                        
        for (int i =0;i < sSize;++i)
        {
            if (s[i] != t[i])
            {
                if (sSize == tSize)
                {
                    return s.substr(i + 1) == t.substr(i + 1);
                }
                else
                {
                    return s.substr(i) == t.substr(i + 1);
                }
            }
        }

        return (sSize + 1 == tSize);
    }
};

LeetCode72. 编辑距离(LeetCode161. 相距为1的编辑距离进阶)

https://leetcode-cn.com/problems/edit-distance/

给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

  • 插入一个字符
  • 删除一个字符
  • 替换一个字符
输入：word1 = "horse", word2 = "ros"
输出：3
解释：
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')
思路

1.思考状态：找出最优解的性质，明确状态表示什么

dp[i] [j]表示长度为i的字符串word1和长度为j的字符串word2的编辑距离，即[0, i - 1]的字符串word1变换到[0, j - 1]的字符串word2的最少操作数。

2.思考状态转移方程：大问题的最有解如何由小问题的最优解得到

主要就是两大情况：word1[i - 1] 与word2[j - 1]相同，word1[i - 1] 与word2[j - 1]不相同

  • if (word1[i - 1] == word2[j - 1]): dp[i] [j] = dp[i - 1] [j - 1]

​ 因为word1[i - 1]等于word2[j - 1]，所以无需进行操作

  • if (word1[i - 1] != word2[j - 1]):

​ dp[i] [j] = 1 + min(dp[i - 1] [j], dp[i] [j - 1], dp[i - 1] [j - 1])

​ 其中，dp[i-1] [j-1] 表示替换操作，dp[i-1] [j] 表示删除操作，dp[i] [j-1]表示插

​ 入操作。

3.思考初始状态

从空串变换到[0, i - 1]的字符串word1的最少操作数为i，所以dp[i] [0] = i

同理，dp[0] [j] = j

4.自底向上计算得到最优解

        for (int i = 1;i <= size1;++i)
        {
            for (int j = 1;j <= size2;++j)
            {
                if (word1[i - 1] == word2[j - 1])
                {
                    dp[i][j] = dp[i - 1][j - 1];
                }
                else
                {
                    dp[i][j] = 1 + min(min(dp[i - 1][j], 
                    dp[i][j - 1]), dp[i - 1][j - 1]);
                }
            }
        }

5.思考是否可以进行空间的优化

代码
class Solution 
{
public:
    int minDistance(string word1, string word2) 
    {
        int size1 = word1.size();
        int size2 = word2.size();

        int dp[size1 + 1][size2 + 1];
        dp[0][0] = 0;
        for (int i = 1;i <= size1;++i)
        {
            dp[i][0] = i;
        }

        for (int j = 1;j <= size2;++j)
        {
            dp[0][j] = j;
        }

        for (int i = 1;i <= size1;++i)
        {
            for (int j = 1;j <= size2;++j)
            {
                if (word1[i - 1] == word2[j - 1])
                {
                    dp[i][j] = dp[i - 1][j - 1];
                }
                else
                {
                    dp[i][j] = 1 + min(min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]);
                }
            }
        }

        return dp[size1][size2];
    }
};

 word2.size();

        int dp[size1 + 1][size2 + 1];
        dp[0][0] = 0;
        for (int i = 1;i <= size1;++i)
        {
            dp[i][0] = i;
        }

        for (int j = 1;j <= size2;++j)
        {
            dp[0][j] = j;
        }

        for (int i = 1;i <= size1;++i)
        {
            for (int j = 1;j <= size2;++j)
            {
                if (word1[i - 1] == word2[j - 1])
                {
                    dp[i][j] = dp[i - 1][j - 1];
                }
                else
                {
                    dp[i][j] = 1 + min(min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]);
                }
            }
        }

        return dp[size1][size2];
    }
};
上帝爱民
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【算法详解】动态规划：经典问题&拓展应用
Ronaldo7_ZYB的博客
01-25 283
最长上升子序列LIS 问题：求一串数字的最长上升子序列 设f[i]f[i]f[i]为以第i位数字结尾的子序列的最大长度.当我们枚举i时，我们需要从左往右枚举i前面的数字jjj，若数字jjj小于数字iii则说明数字i可以在以j结尾的序列之后，因此f[j]+1f[j]+1f[j]+1是一种方案数.若没有比i小的时候，则f[i]=1f[i]=1f[i]=1.故状态转移方程是： f(i)=max{f[j]...
动态规划之子序列问题
小朱小朱绝不认输的博客
11-26 2962
文章目录一、动态规划之子序列问题二、leetcode例题讲解子序列问题1. 子序列（不连续）300. 最长递增子序列1143. 最长公共子序列1035. 不相交的线2. 子序列（连续）674. 最长连续递增序列718. 最长重复子数组53. 最大子序和3. 编辑距离392. 判断子序列115. 不同的子序列583. 两个字符串的删除操作72. 编辑距离4. 回文串647. 回文子串516. 最长回文子序列 子序列问题是动态规划中一系列常见的问题，有多个种类，这里对动态规划的子序列问题进行汇总。 一、动态规划
动态规划-子序列
daxiongwuwuwuw的博客
03-30 205
公共子序列问题系列 leetcode 1143 最长公共子序列 题目： 输入两个字符串s1和s2，找出最长公共子序列，返回这个子序列的长度。 函数签名如下： int longestCommonSubsequence(String s1, String s2); 子序列的问题一般都是两个指针移动求解。如下，我们设置两个指针i与j 那么假设数组A长度为m，数组B长度为n，那么我们会有dp[i][j]，{0<=i<m,0<=j<n 。}表示A[i->m]以及B[j->n]之间
动态规划中的子序列问题
qq_46514141的博客
07-14 162
这题主要是要想清楚dp[i]的含义，即dp[i]表示以nums[i]结尾的最长递增子序列的长度。所以我们每次都要把nums[i]和前面的每个dp[i]比较来得到当前最大的长度。即转移方程为 由此代码就比较好写了。 674. 最长连续递增序列 这题就比较简单了吧，特别在上一题的基础上，这个要求连续，所以每次只需要和前面一个比较即可，也可以用贪心来做，这样空间复杂度会降为O(1). 718. 最长重复子数组 这个题说难也不难，反正dp数组的定义要落在以某个数结尾上来，这里dp[i] [j]表示以nums1的第i
【算法】动态规划法——最长公共子序列（LCS）
热门推荐
不用先生的博客
02-09 7万+
【fishing-pan：https://blog.csdn.net/u013921430转载请注明出处】前言       这篇是自己写的第一篇关于算法方面的博客，写他是因为自己今天打开笔记，刚好看到了它，就这么简单。       这篇博客主要想讲讲动态规划法，然后以LCS问题为例展开来说一下怎么利用动态规划法求解它，下面是自己的一些理解和总结，有不对的地方还请大家指正。动态规划法       动...
动态规划有哪些经典题目？
最新发布
Good_tea_h的博客
07-25 1188
设rn为长度为n的钢条能获得的最大收益，则rn就是我们要找的最优解。
SpringBoot中fastjson扩展: 自定义序列化和反序列化方法实战
码到三十五
07-20 1万+
fastjson允许用户自定义序列化器，用于控制特定类型的序列化过程。用户需要实现接口，并重写write方法。@Override// 自定义序列化逻辑在序列化过程中，可以通过枚举值来指定使用自定义序列化器。fastjson允许用户自定义日期格式。可以通过枚举值和来指定日期格式。此外，用户还可以通过DateFormat属性来指定全局的日期格式。类似地，fastjson也支持自定义反序列化器。用户需要实现接口，并重写deserialze方法。
线性动态规划解析：如何应对单序列问题的动态规划挑战
动态规划（Dynamic Programming，简称DP）是一种解决复杂问题的有效算法思想，它将大问题分解为一系列子问题，并通过递推求解子问题的最优值，最终得到原问题的最优解。动态规划通常适用于具有重叠子问题和最优子...
反存在系列及其Hurst指数：蚂蚁持续系列-matlab开发
05-30
4. **统计分析**：计算子序列均值的差异或方差，分析这些差异或方差随子序列长度的变化规律。 5. **计算Hurst指数**：通过统计结果，可以利用各种方法计算Hurst指数，如R/S分析、嵌入维数法、偏最小二乘回归等。...
动态规划的特点及其应用
02-19
1. 多样性：动态规划不是单一的算法，而是一种算法设计方法，可以用多种方式实现，适用于不同类型的多阶段决策问题。 2. 模式性：尽管问题的表面形态各异，但动态规划解决问题的方式通常遵循一定的模式，这些模式...
NOI/NOIP中的DP（动态规划）类型
11-14
### NOI/NOIP中的DP（动态规划）类型 在计算机科学和编程竞赛中，动态规划（Dynamic Programming，简称DP）是一种解决复杂问题的有效方法。它通过将问题分解为更小的子问题，并存储子问题的解来避免重复计算，从而...
浅谈序列二次规划方法及其相容性问题的处理
02-07
该方法的核心思想是将原问题转化为一系列的二次规划子问题，逐步逼近最优解。 在SQP方法中，首先定义一个初始解，然后在每次迭代时，构造一个二次近似模型来代替原问题的非线性部分。这个二次模型通常是基于...
动态规划——子序列问题
Psychosocial的博客
04-14 2195
一、最长上升子序列（LIS） 1、输出长度 问题描述： 一个数的序列bi，当b1<b2<…<bS的时候，我们称这个序列是上升的。比如，对于序列(1,7,3,5,9,4,8)，有它的一些上升子序列，如(1,7),(3,4,8)等等。这些子序列中最长的长度是4，比如子序列(1,3,5,8)。 你的任务，就是对于给定的序列，求出最长上升子序列的长度。 输入 输入的第一行是序列的长度N...
数组：双指针法
qq_44781747的博客
03-30 772
LeetCode27. 移除元素 https://leetcode-cn.com/problems/remove-element/ 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素 输入：nums = [3,2,2,3], val = 3 输出：2, nums = [2,2] 解释：函数应该返回新的长
哈希表：数组、set、map作哈希表
qq_44781747的博客
03-30 687
LeetCode242. 有效的字母异位词 https://leetcode-cn.com/problems/valid-anagram/ 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。 输入: s = "anagram", t = "nagaram" 输出: true 输入: s = "rat", t = "car" 输出: false 思路 使用数组作为哈希表。 字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下表0，相应的字符z映射为下表25。 在遍
二叉树：构造二叉树
qq_44781747的博客
04-09 579
LeetCode106. 从中序与后序遍历序列构造二叉树 https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/ 根据一棵树的中序遍历与后序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如，给出 中序遍历 inorder = [9,3,15,20,7] 后序遍历 postorder = [9,15,7,20,3] 返回如下的二叉树： 3 / \
动态规划：买卖股票的最佳时机问题
qq_44781747的博客
11-11 507
leetcode121.买卖股票的最佳时机 I https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/ 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。 注意：你不能在买入股票前卖出股票。 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6
数组：二分查找
qq_44781747的博客
03-30 478
LeetCode704. 二分查找 https://leetcode-cn.com/problems/binary-search/ 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 思路 这道题目中的数组是有序数组，这也是使用二分查找的基础条件。只
算法练习一
qq_44781747的博客
11-11 360
算法分析与设计 练习一 内容一 分别针对随机生成的若干组整数序列进行排序，排序算法使用四种方法。 1.InsertSort 源码： #include <iostream> #include <vector> #include <cstdlib> #include <ctime> using namespace std; //插入排序 void InsertSort(vector<int>& nums) { int size =
动态规划解析：币值最大化问题及其实现
总结起来，动态规划是一种强大的算法思想，适用于解决许多优化问题，如背包问题、最长公共子序列、最短路径等。通过理解动态规划的基本原理，以及如何构建正确的状态转移方程，我们可以有效地解决这些问题，避免不必...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值