代码随想录 动态规划-子序列问题-编辑距离

最新推荐文章于 2024-11-14 21:21:03 发布
最新推荐文章于 2024-11-14 21:21:03 发布
阅读量701 收藏 22
点赞数 24
分类专栏： 代码随想录 文章标签： 算法 leetcode 数据结构 动态规划 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74267125/article/details/136986280
版权

目录

392.判断子序列

115.不同的子序列

583.两个字符串

72.编辑距离

392.判断子序列

392. 判断子序列

简单

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

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

进阶：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

致谢：

特别感谢 @pbrother 添加此问题并且创建所有测试用例。

示例 1：

输入：s = "abc", t = "ahbgdc"
输出：true

示例 2：

输入：s = "axc", t = "ahbgdc"
输出：false

提示：

  • 0 <= s.length <= 100
  • 0 <= t.length <= 10^4
  • 两个字符串都只由小写字符组成。

动态规划五部曲分析如下：

确定dp数组（dp table）以及下标的含义

dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。

确定递推公式

在确定递推公式的时候，首先要考虑如下两种操作，整理如下：

if (s[i - 1] == t[j - 1])

t中找到了一个字符在s中也出现了

if (s[i - 1] != t[j - 1])

相当于t要删除元素，继续匹配

if (s[i - 1] == t[j - 1])，那么dp[i][j] = dp[i - 1][j - 1] + 1;，因为找到了一个相同的字符，相同子序列长度自然要在dp[i-1][j-1]的基础上加1（如果不理解，在回看一下dp[i][j]的定义）

if (s[i - 1] != t[j - 1])，此时相当于t要删除元素，t如果把当前元素t[j - 1]删除，那么dp[i][j] 的数值就是 看s[i - 1]与 t[j - 2]的比较结果了，即：dp[i][j] = dp[i][j - 1];

其实这里 大家可以发现和 1143.最长公共子序列 (opens new window)的递推公式基本那就是一样的，区别就是 本题 如果删元素一定是字符串t，而 1143.最长公共子序列 是两个字符串都可以删元素。

dp数组如何初始化

从递推公式可以看出dp[i][j]都是依赖于dp[i - 1][j - 1] 和 dp[i][j - 1]，所以dp[0][0]和dp[i][0]是一定要初始化的。

这里大家已经可以发现，在定义dp[i][j]含义的时候为什么要表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。

因为这样的定义在dp二维矩阵中可以留出初始化的区间，如图：

392.判断子序列

如果要是定义的dp[i][j]是以下标i为结尾的字符串s和以下标j为结尾的字符串t，初始化就比较麻烦了。

dp[i][0] 表示以下标i-1为结尾的字符串，与空字符串的相同子序列长度，所以为0. dp[0][j]同理。

vector<vector<int>> dp(s.size() + 1, vector<int>(t.size() + 1, 0));

确定遍历顺序

同理从递推公式可以看出dp[i][j]都是依赖于dp[i - 1][j - 1] 和 dp[i][j - 1]，那么遍历顺序也应该是从上到下，从左到右

如图所示：

392.判断子序列1

举例推导dp数组

以示例一为例，输入：s = "abc", t = "ahbgdc"，dp状态转移图如下：

392.判断子序列2

dp[i][j]表示以下标i-1为结尾的字符串s和以下标j-1为结尾的字符串t 相同子序列的长度，所以如果dp[s.size()][t.size()] 与 字符串s的长度相同说明：s与t的最长相同子序列就是s，那么s 就是 t 的子序列。

图中dp[s.size()][t.size()] = 3， 而s.size() 也为3。所以s是t 的子序列，返回true。

class Solution {
    public boolean isSubsequence(String s, String t) {
        // 创建一个二维数组来存储匹配的字符数量
        // dp[i][j] 表示 s[0..i-1] 和 t[0..j-1] 中匹配的字符数量
        int[][] dp = new int[s.length() + 1][t.length() + 1];
        
        // 遍历 s 和 t 中的每个字符
        for(int i = 1; i <= s.length(); i++){
            for(int j = 1; j <= t.length(); j++){
                // 如果字符匹配，将 dp[i-1][j-1] 的值加 1 存入 dp[i][j]
                if(s.charAt(i - 1) == t.charAt(j - 1)){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    // 如果字符不匹配，将 dp[i][j-1] 的值存入 dp[i][j]
                    dp[i][j] = dp[i][j - 1];
                }
            }
        }
        
        // 如果 dp[s.length()][t.length()] 的值等于 s.length()，则 s 是 t 的子序列
        if(dp[s.length()][t.length()] == s.length()){
            return true;
        }
        return false;
    }
}

115.不同的子序列

115. 不同的子序列

困难

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。

示例 1：

输入：s = "rabbbit", t = "rabbit"
输出：3
解释：
如下所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
rabbbit
rabbbit
rabbbit

示例 2：

输入：s = "babgbag", t = "bag"
输出：5
解释：
如下所示, 有 5 种可以从 s 中得到 "bag" 的方案。 
babgbag
babgbag
babgbag
babgbag
babgbag

提示：

  • 1 <= s.length, t.length <= 1000
  • s 和 t 由英文字母组成

动规五部曲分析如下：

确定dp数组（dp table）以及下标的含义

dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。

为什么i-1，j-1 这么定义我在 718. 最长重复子数组 (opens new window)中做了详细的讲解。

确定递推公式

这一类问题，基本是要分析两种情况

s[i - 1] 与 t[j - 1]相等

s[i - 1] 与 t[j - 1] 不相等

当s[i - 1] 与 t[j - 1]相等时，dp[i][j]可以有两部分组成。

一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]。即不需要考虑当前s子串和t子串的最后一位字母，所以只需要 dp[i-1][j-1]。

一部分是不用s[i - 1]来匹配，个数为dp[i - 1][j]。

这里可能有录友不明白了，为什么还要考虑 不用s[i - 1]来匹配，都相同了指定要匹配啊。

例如： s：bagg 和 t：bag ，s[3] 和 t[2]是相同的，但是字符串s也可以不用s[3]来匹配，即用s[0]s[1]s[2]组成的bag。

当然也可以用s[3]来匹配，即：s[0]s[1]s[3]组成的bag。

所以当s[i - 1] 与 t[j - 1]相等时，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];

当s[i - 1] 与 t[j - 1]不相等时，dp[i][j]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素），即：dp[i - 1][j]

所以递推公式为：dp[i][j] = dp[i - 1][j];

这里可能有录友还疑惑，为什么只考虑 “不用s[i - 1]来匹配” 这种情况， 不考虑 “不用t[j - 1]来匹配” 的情况呢。

这里大家要明确，我们求的是 s 中有多少个 t，而不是 求t中有多少个s，所以只考虑 s中删除元素的情况，即 不用s[i - 1]来匹配 的情况。

dp数组如何初始化

从递推公式dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; 和 dp[i][j] = dp[i - 1][j]; 中可以看出dp[i][j] 是从上方和左上方推导而来，如图：，那么 dp[i][0] 和dp[0][j]是一定要初始化的。

每次当初始化的时候，都要回顾一下dp[i][j]的定义，不要凭感觉初始化。

dp[i][0]表示什么呢？

dp[i][0] 表示：以i-1为结尾的s可以随便删除元素，出现空字符串的个数。

那么dp[i][0]一定都是1，因为也就是把以i-1为结尾的s，删除所有元素，出现空字符串的个数就是1。

再来看dp[0][j]，dp[0][j]：空字符串s可以随便删除元素，出现以j-1为结尾的字符串t的个数。

那么dp[0][j]一定都是0，s如论如何也变成不了t。

最后就要看一个特殊位置了，即：dp[0][0] 应该是多少。

dp[0][0]应该是1，空字符串s，可以删除0个元素，变成空字符串t。

初始化分析完毕，代码如下：

vector<vector<long long>> dp(s.size() + 1, vector<long long>(t.size() + 1));
for (int i = 0; i <= s.size(); i++) dp[i][0] = 1;
for (int j = 1; j <= t.size(); j++) dp[0][j] = 0; // 其实这行代码可以和dp数组初始化的时候放在一起，但我为了凸显初始化的逻辑，所以还是加上了。

确定遍历顺序

从递推公式dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; 和 dp[i][j] = dp[i - 1][j]; 中可以看出dp[i][j]都是根据左上方和正上方推出来的。

所以遍历的时候一定是从上到下，从左到右，这样保证dp[i][j]可以根据之前计算出来的数值进行计算。

代码如下：

for (int i = 1; i <= s.size(); i++) {
    for (int j = 1; j <= t.size(); j++) {
        if (s[i - 1] == t[j - 1]) {
            dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
        } else {
            dp[i][j] = dp[i - 1][j];
        }
    }
}

举例推导dp数组

以s："baegg"，t："bag"为例，推导dp数组状态如下：

115.不同的子序列

如果写出来的代码怎么改都通过不了，不妨把dp数组打印出来，看一看，是不是这样的。

 

class Solution {
    public int numDistinct(String s, String t) {
        // 创建一个二维数组来存储不同子序列的数量
        // dp[i][j] 表示 s[0..i-1] 和 t[0..j-1] 的不同子序列数量
        int[][] dp = new int[s.length() + 1][t.length() + 1];
        
        // 基本情况：对于任何字符串 s，形成空字符串的方法恰好一种。
        // 因此，对所有 i，初始化 dp[i][0] 为 1。
        for (int i = 0; i < s.length() + 1; i++) {
            dp[i][0] = 1;
        }
        
        // 遍历 s 和 t 中的每个字符
        for(int i = 1; i <= s.length(); i++){
            for(int j = 1; j <= t.length(); j++){
                // 如果字符匹配，有两种选择：
                // 1. 将当前字符包含在 s 和 t 中。因此，将 dp[i-1][j-1] 加到 dp[i][j]。
                // 2. 从 s 中排除当前字符，但保留 t 不变。因此，将 dp[i-1][j] 加到 dp[i][j]。
                if(s.charAt(i - 1) == t.charAt(j - 1)){
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                } else {
                    // 如果字符不匹配，我们只能排除 s 中的当前字符。
                    // 因此，将 dp[i-1][j] 加到 dp[i][j]。
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        
        // 返回 s 和 t 的不同子序列数量
        return dp[s.length()][t.length()];
    }
}

583.两个字符串

583. 两个字符串的删除操作

中等

给定两个单词 word1 和 word2 ，返回使得 word1 和  word2 相同所需的最小步数。

每步 可以删除任意一个字符串中的一个字符。

示例 1：

输入: word1 = "sea", word2 = "eat"
输出: 2
解释: 第一步将 "sea" 变为 "ea" ，第二步将 "eat "变为 "ea"

示例  2:

输入：word1 = "leetcode", word2 = "etco"
输出：4

提示：

  • 1 <= word1.length, word2.length <= 500
  • word1 和 word2 只包含小写英文字母

这道题可以转变思路，找出两个字符串的最大公共子序列，然后通过长度找出删除元素的最小个数 ，变成求最大公共子序列的问题

代码随想录 动态规划-子序列问题-子序列（不连续）-CSDN博客 

class Solution {
    public int minDistance(String word1, String word2) {
        // 创建一个二维数组来存储最长公共子序列的长度
        // dp[i][j] 表示 word1[0..i-1] 和 word2[0..j-1] 的最长公共子序列长度
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        
        // 遍历 word1 和 word2 中的每个字符
        for(int i = 1; i <= word1.length(); i++){
            for(int j = 1; j <= word2.length(); j++){
                // 如果字符相等，将 dp[i-1][j-1] 的值加 1 存入 dp[i][j]
                if(word1.charAt(i - 1) == word2.charAt(j - 1)){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    // 如果字符不相等，将 dp[i-1][j] 和 dp[i][j-1] 中的较大值存入 dp[i][j]
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        
        // 最终返回 word1 和 word2 的长度减去它们的最长公共子序列的长度的两倍
        return word1.length() + word2.length() - 2 * dp[word1.length()][word2.length()];
    }
}

直接求解删除的步数

这次是两个字符串可以相互删了，这种题目也知道用动态规划的思路来解，动规五部曲，分析如下：

确定dp数组（dp table）以及下标的含义

dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。

这里dp数组的定义有点点绕，大家要撸清思路。

确定递推公式

当word1[i - 1] 与 word2[j - 1]相同的时候

当word1[i - 1] 与 word2[j - 1]不相同的时候

当word1[i - 1] 与 word2[j - 1]相同的时候，dp[i][j] = dp[i - 1][j - 1];

当word1[i - 1] 与 word2[j - 1]不相同的时候，有三种情况：

情况一：删word1[i - 1]，最少操作次数为dp[i - 1][j] + 1

情况二：删word2[j - 1]，最少操作次数为dp[i][j - 1] + 1

情况三：同时删word1[i - 1]和word2[j - 1]，操作的最少次数为dp[i - 1][j - 1] + 2

那最后当然是取最小值，所以当word1[i - 1] 与 word2[j - 1]不相同的时候，递推公式：dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});

因为 dp[i][j - 1] + 1 = dp[i - 1][j - 1] + 2，所以递推公式可简化为：dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);

这里可能不少录友有点迷糊，从字面上理解 就是 当 同时删word1[i - 1]和word2[j - 1]，dp[i][j-1] 本来就不考虑 word2[j - 1]了，那么我在删 word1[i - 1]，是不是就达到两个元素都删除的效果，即 dp[i][j-1] + 1。

dp数组如何初始化

从递推公式中，可以看出来，dp[i][0] 和 dp[0][j]是一定要初始化的。

dp[i][0]：word2为空字符串，以i-1为结尾的字符串word1要删除多少个元素，才能和word2相同呢，很明显dp[i][0] = i。

dp[0][j]的话同理，所以代码如下：

vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1));
for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;

确定遍历顺序

从递推公式 dp[i][j] = min(dp[i - 1][j - 1] + 2, min(dp[i - 1][j], dp[i][j - 1]) + 1); 和dp[i][j] = dp[i - 1][j - 1]可以看出dp[i][j]都是根据左上方、正上方、正左方推出来的。

所以遍历的时候一定是从上到下，从左到右，这样保证dp[i][j]可以根据之前计算出来的数值进行计算。

举例推导dp数组

以word1:"sea"，word2:"eat"为例，推导dp数组状态图如下：

583.两个字符串的删除操作1

class Solution {
    public int minDistance(String word1, String word2) {
        // 创建一个二维数组来存储编辑距离
        // dp[i][j] 表示将 word1[0..i-1] 转换为 word2[0..j-1] 所需的最小操作次数
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        
        // 初始化第一行和第一列
        // dp[i][0] 表示将 word1 的前 i 个字符转换为一个空字符串所需的操作次数，即删除操作
        for (int i = 0; i < word1.length() + 1; i++) dp[i][0] = i;
        // dp[0][j] 表示将空字符串转换为 word2 的前 j 个字符所需的操作次数，即插入操作
        for (int j = 0; j < word2.length() + 1; j++) dp[0][j] = j;
        
        // 遍历 word1 和 word2 中的每个字符
        for (int i = 1; i < word1.length() + 1; i++) {
            for (int j = 1; j < word2.length() + 1; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    // 如果当前字符相等，无需操作，保持相等
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    // 如果当前字符不相等，考虑三种操作的最小值：
                    // 1. 替换操作：将 word1[i-1] 替换为 word2[j-1]，需要消耗 2 步（删除 + 插入）
                    // 2. 删除操作：删除 word1[i-1]，需要消耗 1 步
                    // 3. 插入操作：在 word1[i-1] 后插入 word2[j-1]，需要消耗 1 步
                    dp[i][j] = Math.min(dp[i - 1][j - 1] + 2,
                                        Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
                }
            }
        }
        
        // 返回将 word1 转换为 word2 所需的最小操作次数
        return dp[word1.length()][word2.length()];
    }
}

72.编辑距离

72. 编辑距离

中等

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

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

  • 插入一个字符
  • 删除一个字符
  • 替换一个字符

示例 1：

输入：word1 = "horse", word2 = "ros"
输出：3
解释：
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')

示例 2：

输入：word1 = "intention", word2 = "execution"
输出：5
解释：
intention -> inention (删除 't')
inention -> enention (将 'i' 替换为 'e')
enention -> exention (将 'n' 替换为 'x')
exention -> exection (将 'n' 替换为 'c')
exection -> execution (插入 'u')

提示：

  • 0 <= word1.length, word2.length <= 500
  • word1 和 word2 由小写英文字母组成
class Solution {
    public int minDistance(String word1, String word2) {
        // 创建一个二维数组来存储编辑距离
        // dp[i][j] 表示将 word1[0..i-1] 转换为 word2[0..j-1] 所需的最小操作次数
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        
        // 初始化第一行和第一列
        // dp[i][0] 表示将 word1 的前 i 个字符转换为一个空字符串所需的操作次数，即删除操作
        for(int i = 0; i <= word1.length(); i++){
            dp[i][0] = i; 
        }
        // dp[0][j] 表示将空字符串转换为 word2 的前 j 个字符所需的操作次数，即插入操作
        for(int j = 0; j <= word2.length(); j++){
            dp[0][j] = j;
        }
        
        // 遍历 word1 和 word2 中的每个字符
        for(int i = 1; i <= word1.length(); i++){
            for(int j = 1; j <= word2.length(); j++){
                if(word1.charAt(i - 1) == word2.charAt(j - 1)){
                    // 如果当前字符相等，无需操作，保持相等
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    // 如果当前字符不相等，考虑三种操作的最小值：
                    // 1. 替换操作：将 word1[i-1] 替换为 word2[j-1]，需要消耗 1 步
                    // 2. 删除操作：删除 word1[i-1]，需要消耗 1 步
                    // 3. 插入操作：在 word1[i-1] 后插入 word2[j-1]，需要消耗 1 步
                    dp[i][j] = Math.min(dp[i - 1][j] + 1, Math.min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1));
                }
            }
        }
        
        // 返回将 word1 转换为 word2 所需的最小操作次数
        return dp[word1.length()][word2.length()];
    }
}

 

XiaoMing_Coder
关注
专栏目录
代码随想录-035期-算法训练营【博客笔记汇总表】
upward
04-10 661
代码随想录-035期-算法训练营【博客笔记汇总表】
leecode刷题笔记--代码随想录--动态规划--子序列
xixixixixiyu的博客
11-19 180
这部分题建立dp数组时，dp[i]表明的是使用第i个数值时候的情况。
代码随想录笔记--动态规划篇
牵一只蜗牛去散步
09-21 607
当 word1[i-1] 不等于 word2[j-1] 时，dp[i][j] = std::min(dp[i-1][j-1] + 1, std::min(dp[i-1][j] + 1, dp[i][j-1] + 1))；当s[i] = t[j] 时，dp[i][j] = dp[i-1][j-1] + dp[i-1][j]；初始化：dp[0][0] = 0，dp[0][1] = -prices[0]，dp[0][2] = 0，dp[0][3] = -prices[0]，dp[0][4] = 0；
代码随想录-动态规划
Greedy Hat的博客
03-01 495
代码随想录-动态规划
代码随想录 - 动态规划 - 子序列，子数组
Genelove1974的博客
05-08 170
给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。动态规划，利用dp[i]保存以nums[i]结尾的最长递增子序列长度。dp[i]更新：对于j从0到i - 1的取值，dp[i] = max(dp[j] + 1, dp[i]);
「代码随想录」动态规划专题精讲（v1.2）.pdf
07-15
例如，在字符串处理中，动态规划可以用来计算两个字符串的最长公共子序列长度，或者用于字符串的编辑距离计算等。 总的来说，「代码随想录」动态规划专题精讲（v1.2）.pdf 是一本专注于讲解动态规划的算法书籍。它...
「代码随想录」动态规划专题精讲（v1.1）.pdf
08-03
不过，根据文档标题《「代码随想录」动态规划专题精讲（v1.1）.pdf》可以推测这份文档可能是一份关于动态规划（Dynamic Programming，简称DP）的学习材料。 动态规划是算法设计中一种重要的思想方法，主要用于解决...
代码随想录day43：动态规划part11，子序列问题，一直到“编辑距离”
O_ra_Cle的博客
03-20 288
dp数组定义 i-1 j-1 是为了省略初始化，如果定义为以 i j 结尾需要对 dp[0] 的情况初始化。
代码随想录：动态规划深度解析
7. 典型问题：可能包括“最长公共子序列”、“背包问题”、“斐波那契数列”、“最小编辑距离”等经典动态规划问题的详解和解决方案。 8. 代码实现：提供用不同编程语言（如C++、Java、Python、Go、JavaScript等）...
代码随想录动态规划——编辑距离
qq_39473176的博客
11-03 377
刷题总结
「代码随想录」动态规划详解：核心概念与实践技巧
2. **常见动态规划问题**：可能包括了经典的动态规划问题，如斐波那契数列、最长公共子序列、背包问题、最小编辑距离等。这些例子帮助读者理解和应用动态规划方法。 3. **状态压缩与滚动数组**：在处理较大状态空间...
DAY63||拓扑排序精讲 |dijkstra（朴素版）精讲
2301_79865280的博客
11-14 358
某个大型软件项目的构建系统拥有 N 个文件，文件编号从 0 到 N - 1，在这些文件中，某些文件依赖于其他文件的内容，这意味着如果文件 A 依赖于文件 B，则必须在处理文件 A 之前处理文件 B （0 <= A, B <= N - 1）。请编写一个算法，用于确定文件处理的顺序。第一行输入两个正整数 N, M。表示 N 个文件之间拥有 M 条依赖关系。后续 M 行，每行两个正整数 S 和 T，表示 T 文件依赖于 S 文件。输出共一行，如果能处理成功，则输出文件顺序，用空格隔开。
java计算文本相似度算法总结
sunsiny
11-14 504
计算两个字符串之间的最小单字符编辑（插入、删除、替换）次数。这是一种衡量字符串差异性的方法，常用于拼写检查和模糊匹配。：一种基于 Jaro 相似度的改进算法，特别适用于拼写检查和模糊匹配。：计算两个字符串之间的最长公共子序列长度，常用于文本差异比较。：通过计算两个字符串的 n-gram 向量的余弦夹角来评估它们的相似度。：基于子串的字符串相似度计算方法，计算它们共有的Q-gram（长度为Q的连续子串）的数量，然后将这个数量除以两个字符串中Q-gram数量较少的那个，得到相似度的比例。
16 合并区间
weixin_47521269的博客
11-12 718
【代码】16 合并区间。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1496
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
LeetCode题解：3.无重复字符的最长子串【python 题解超详细】
m0_74420622的博客
11-10 765
LeetCode题解：3.无重复字符的最长子串【python 题解超详细】，滑动窗口与暴力求解，知识拓展：什么是哈希函数
每日小题--买股票的最佳时机
最新发布
m0_74977981的博客
11-14 416
毋庸置疑，一定需要数组遍历结束后才能确定这么一个买入点和卖出点，所以此时想要提升算法的话就要找到一个只需要遍历一遍就能出结果的方法，即将时间复杂度控制在O(n)；遍历数组的过程中去找数组中是否存在一个低价点，并且在低价点的基础上去判断有无上升空间；即杜绝了{4，3，2，1}的情况出现，买入后无法卖出。在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。后出价最高的一天卖出，简而言之，就是找到一个比起始小，并且结尾在一个有最大差距的位置；
14 最长连续序列
weixin_47521269的博客
11-11 571
O1这个算法的时间复杂度是 O(n)，因为每个数字最多只会被处理一次，符合题目要求的时间复杂度。
动态规划---算法中的坚持仙蛊
2301_77174919的博客
11-14 378
然后再写代码，如果代码没通过就打印dp数组，看看是不是和自己预先推导的哪里不一样。如果打印出来和自己预先模拟推导是一样的，那么就是自己的递归公式、初始化或者遍历顺序有问题了。如果和自己预先模拟推导的不一样，那么就是代码实现细节有问题。
力扣－每日温度
m0_63056769的博客
11-10 228
这是我的第一个思路 虽然可以得到正确答案 但是过于暴力 已经超出了时间限制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值