【动态规划】字符串系列 （题目笔记）

已于 2022-03-10 23:36:46 修改
阅读量815 收藏 3
点赞数
于 2022-03-10 23:31:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangliming123/article/details/123411721
版权

动态规划 字符串处理 最长公共子序列 最长回文子串 编辑距离
关键词由CSDN通过智能技术生成

 ​​​​​​​1143. 最长公共子序列

最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

  • 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 1：

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

示例 2：

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

示例 3：

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0 。

提示：

  • 1 <= text1.length, text2.length <= 1000
  • text1 和 text2 仅由小写英文字符组成。

1.dp数组含义：

dp[i][j] 代表 text1中 0~ i 的子串 与 text2 中 0~j  的子串 中 最长的公共子序列的长度

2.状态转移方程：

                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]);

                如果text1的第i个字符与text2中第j个字符相等，那么text1中 0~ i 的子 串 与 text2 中 0~j  的子串 中 最长的公共子序列的长度 = text1中 0~ i -1的      子 串 与 text2 中 0~j -1 的子串 中 最长的公共子序列的长度 + 1；

                如果不相等，= text1中 0~ i -1的 子 串 与 text2 中 0~j 的子串 中 最长的公共子序列的长度  与    text1中 0~ i 的 子 串 与 text2 中 0~j 的子串 中 最长的公共子序列的长度 两者之间的最大值。

3.初始化：

        dp[i][0] = dp[0][j] = 0;

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int m = text1.size() + 1;
        int n = text2.size() + 1;
        vector<vector<int>> dp(m,vector<int>(n,0));
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; 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[m-1][n-1];
    }
};

变：最长公共子串

只需考虑text[i] == text[j] 的 情况即可，代码如下

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int LCSubstr(string& s, string& t){
	int ls = s.size();
	int lt = t.size();
	vector<vector<int>> dp = vector<vector<int>>(ls + 1, vector<int>(lt + 1, 0));
	int maxl = 0;
	for(int i = 1; i <= ls; i++){
		for(int j = 1; j <= lt; j++){
			if(s[i-1] == t[j-1]){
				 dp[i][j] = dp[i-1][j-1] + 1;
			}
			maxl = max(maxl, dp[i][j]);
		}
	}
	return maxl;	
}
int main(){
	string s, t;
	cin >> s >> t;
	cout << LCSubstr(s , t);
	return 0;
}

最长回文子串

5. 最长回文子串

难度中等4836收藏分享切换为英文接收动态反馈

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

示例 2：

输入：s = "cbbd"
输出："bb"

提示：

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

回文系列的题目，dp数组不出意外的话，dp[i][j]代表的是 下标从i到j的子串是否为回文串

i与j通过长度len(1 ~ n) 相联系

状态转移方程：P(i,j)=P(i+1,j−1)∧(Si​==Sj​)

初始化：子串长度 l 为 1 ： d[i][i] = 1;

               l 长度为2:

                        如果s[i] == s[i+1]

                                dp[i][i+1] = 1；

注意状态转移方程通过子串长度 l 从 3 到 ​​​​​​​len 把i和j联系起来：j = i + l -1;

max 用来记录 最长 回文子串长度，start用来记录该子串开始下标

#include<iostream>
#include<string>
#include<vector>
using namespace std;
string longestPalindrome(string s){
	int len = s.size();
	if(len == 0 || len ==1) return s;
	int start = 0, max = 1;
	vector<vector<int>> dp(len, vector<int>(len));
	for(int i = 0; i < len; i++){
		dp[i][i] = 1;
		if(i < len - 1 && s[i]==s[i+1]){
			dp[i][i+1] = 1;
			max = 2;
			start = i;
		}
	} 
	for(int l = 3; l <= len; l++){
		for(int i = 0; i + l - 1 < len; i++){
			int j = l + i -1;
			if(s[i]==s[j] && dp[i+1][j-1]){
				dp[i][j] = 1;
				start = i;
				max = l;
			}
		}
	}
	return s.substr(start, max);
} 

int main(){
	string s;
	cin >> s;
	cout << longestPalindrome(s);
}

最长公共子序列

516. 最长回文子序列

难度中等739收藏分享切换为英文接收动态反馈

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

示例 1：

输入：s = "bbbab"
输出：4
解释：一个可能的最长回文子序列为 "bbbb" 。

示例 2：

输入：s = "cbbd"
输出：2
解释：一个可能的最长回文子序列为 "bb" 。

提示：

  • 1 <= s.length <= 1000
  • s 仅由小写英文字母组成

初始化均和回文子串一样，变动的是状态转移方程：

如果 s[i] = s[j]，则首先得到 s 的下标范围 [i+1, j-1] 内的最长回文子序列，然后在该子序列的首尾分别添加 s[i]和 s[j]，即可得到 s 的下标范围 [i, j] 内的最长回文子序列，因此

dp[i][j]=dp[i+1][j−1]+2；

如果 s[i] != s[j] ，则 s[i]和 s[j] 不可能同时作为同一个回文子序列的首尾，因此

dp[i][j]=max(dp[i+1][j],dp[i][j−1])。

class Solution {
public:
    int longestPalindromeSubseq(string s){
	int n = s.size();
	vector<vector<int>> f(n, vector<int>(n));
	for(int i = 0; i < n; i++){
		f[i][i] = 1;
		if(i < n-1 && s[i] == s[i+1])
			f[i][i+1] = 2;
		else if(i < n-1 && s[i] != s[i+1])
			f[i][i+1] = 1;	
	}
	for(int len = 3; len <= n; len++){
		for(int i = 0; i + len - 1 < n; i++){
			int j = i + len - 1;
            if(s[i] != s[j]) 
			    f[i][j] = max(f[i][j-1], f[i+1][j]);
			if(s[i] == s[j]) 
				f[i][j] = f[i+1][j-1] + 2;
		}
	}
	return f[0][n-1];
}
};

交错字符串

给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。

两个字符串 s 和 t 交错 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串：

s = s1 + s2 + ... + sn
t = t1 + t2 + ... + tm
|n - m| <= 1
交错 是 s1 + t1 + s2 + t2 + s3 + t3 + ... 或者 t1 + s1 + t2 + s2 + t3 + s3 + ...
注意：a + b 意味着字符串 a 和 b 连接。

示例 1：
输入：s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
输出：true
示例 2：

输入：s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
输出：false
示例 3：

输入：s1 = "", s2 = "", s3 = ""
输出：true

提示：

0 <= s1.length, s2.length <= 100
0 <= s3.length <= 200
s1、s2、和 s3 都由小写英文字母组成

f[i][j]代表s1的前i个字符，与s2的前j个字符能否交错组成s3的前i+j的子串
s1和s2总长与s3不等，则肯定不能完成交错，返回false 
 

dp[0][0] =  true; 


1.如果s1的第i个字符和s3的第i+j个字符相等，则意味着如果s1的前i-1个字符与s2的前j个字符可以交错组成s3的前i+j-1个字符的话, s1的前i个和s2的前j个是可以交错组成s3的前i+j个的。
则f[i][j] = (f[i-1][j] && s1[i-1] == s3[p]);
对于s2的第j个字符和s3的第i+j个字符相等, s1的前i个字符与s2的前j-1个字符可以交错组成s3的前i+j-1个字符 同理
 f[i][j] |= (f[1][j-1] && s1[i-1] == s3[p]);
 

注意：第一次是= ， 第二次是|=，因为可能第一种情况满足，第二种不满足 

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        auto f = vector <vector<int>>(s1.size() + 1, vector <int> (s2.size() + 1, false));

        int n = s1.size(), m = s2.size(), t = s3.size();

        if (n + m != t) {
            return false;
        }

        f[0][0] = true;
        for (int i = 0; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                int p = i + j - 1;
                if (i > 0) {
                    f[i][j] = (f[i - 1][j] && s1[i - 1] == s3[p]);
                }
                if (j > 0) {
                    f[i][j] |= (f[i][j - 1] && s2[j - 1] == s3[p]);
                }
            }
        }

        return f[n][m];
    }
};

不同的子序列

115. 不同的子序列

难度困难693收藏分享切换为英文接收动态反馈

给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）

题目数据保证答案符合 32 位带符号整数范围。

示例 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提示：
  • 0 <= s.length, t.length <= 1000
  • s 和 t 由英文字母组成

s-----给定串

t------模式串

dp数组：
     dp[i][j]代表 s 前 i 个字符构成的子串，有 模式串 t 前 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]；

    意思是，如果当s第i个字符与t的第j个字相等时，我们可以有两种选择方式：把s中的第i个字符，作为与t中第j个字符的匹配记录即承接dp[i - 1][j - 1] ​​​​​​​；或者，不让他与之对应，跳过他，当他不存在，承接dp[i - 1][j]

        不相等时就好办了，想让他俩匹配都没办法匹配，直接承接dp[i - 1][j]

 初始化：

        模式串t为空，只有1种方法；

        给定串s为空，t不为空，有0种方法；

        for (int i = 0; i < s.size(); i++) dp[i][0] = 1;

        for (int j = 1; j < t.size(); j++) dp[0][j] = 0;

class Solution {
public:
    int numDistinct(string s, string t) {
        vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(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;
        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];
                }
            }
        }
        return dp[s.size()][t.size()];
    }
};

编辑距离

72. 编辑距离

难度困难2181收藏分享切换为英文接收动态反馈

给你两个单词 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')

动态规划：
dp[i][j] 代表 word1 到 i 位置转换成 word2 到 j 位置需要最少步数

所以，

当 word1[i] == word2[j]，dp[i][j] = dp[i-1][j-1]；

当 word1[i] != word2[j]，dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1

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

注意，针对第一行，第一列要单独考虑，我们引入 '' 下图所示：

第一行，是 word1 为空变成 word2 最少步数，就是插入操作

第一列，是 word2 为空，需要的最少步数，就是删除操作

。

#include<iostream>
#include<vector>
#include<string>
using namespace std;
int minDistance(string word1, string word2){
	vector<vector<int>> dp(word1.size()+1,vector<int>(word2.size()+1, 0));
	for(int i = 0; i < dp.size(); i++) dp[i][0] = i;
	for(int j = 0; j < dp[0].size(); j++) dp[0][j] = j;
	for(int i = 1; i < dp.size(); i++){
		for(int j = 1; j < dp[i].size(); j++){
			dp[i][j] = min(dp[i-1][j-1], min(dp[i-1][j], dp[i][j-1])) + 1;
			if(word1[i-1] == word2[j-1]){
				dp[i][j] = min(dp[i][j], dp[i-1][j-1]);
			}
		}
	}
   return dp.back().back();		
}

int main(){
	string s1, s2;
	getline(cin, s1);
	getline(cin, s2); 
	cout << minDistance(s1,s2);
	return 0;
	
}

通配符匹配

44. 通配符匹配

难度困难831收藏分享切换为英文接收动态反馈

给定一个字符串 (s) 和一个字符模式 (p) ，实现一个支持 '?' 和 '*' 的通配符匹配。

'?' 可以匹配任何单个字符。
'*' 可以匹配任意字符串（包括空字符串）。

两个字符串完全匹配才算匹配成功。

说明:

  • s 可能为空，且只包含从 a-z 的小写字母。
  • p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和 *。

示例 1:

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。

示例 2:

输入:
s = "aa"
p = "*"
输出: true
解释: '*' 可以匹配任意字符串。

示例 3:

输入:
s = "cb"
p = "?a"
输出: false
解释: '?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。

示例 4:

输入:
s = "adceb"
p = "*a*b"
输出: true
解释: 第一个 '*' 可以匹配空字符串, 第二个 '*' 可以匹配字符串 "dce".

示例 5:

输入:
s = "acdcb"
p = "a*c?b"
输出: false
#include<iostream>
#include<string>
#include<vector>
using namespace std;
bool isMatch(string s, string p) {
    int m = s.size();
    int n = p.size();
    vector<vector<int>> dp(m + 1, vector<int>(n + 1));
    dp[0][0] = true;
    for (int i = 1; i <= n; ++i) {
        if (p[i - 1] == '*') {
           dp[0][i] = true;
        }
        else {
            break;
            }
        }
        // a) *表示空字符,则保持i不动，j-1，如果dp[i][j-1]能匹配，则dp[i][j]能匹配
		// b) *表示多字符,则保持j不动，i-1，如果dp[i-1][j]能匹配，则dp[i][j]能匹配
		//     因为*表示多字符,则当前i-1加上一个字符后的i也就能匹配
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (p[j - 1] == '*') {
                    dp[i][j] = dp[i][j - 1] | dp[i - 1][j];
                }
                else if (p[j - 1] == '?' || s[i - 1] == p[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                }
            }
        }
        return dp[m][n];
    }


int main(){
		string s,p; 
		cin>> s >> p;
		cout << isMatch(s, p) << endl;
	
	

}

jiangliming123
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法笔记——字符串的算术运算
程序媛的自学笔记
08-13 2452
1.字符串的加法运算 练习题：Leetcode#415 1.1题目 1.2算法思路 按照模拟「竖式加法」的思路，从最低位开始按位相加，用add记录进位，两个字符串中较短者的高位需要自动补0，将最后得到的结果进行反转即可返回。 1.3 代码实现 class Solution { public: string addStrings(string num1, string num2) { int i = num1.size() - 1; int j = num2.size
笔记——动态规划字符串类题目小结
皮蛋瘦肉没有肉
01-16 524
题目1：最大递增子序列    我的代码 给定数组arr，返回arr最长递增子序列长度。比如arr=[2,1,5,3,6,4,8,9,7],最长递增子序列为[1,3,4,8,9],所以返回5 题目2：最长公共子序列    我的代码 给定两个字符串，求解这两个字符串的最长公共子序列（Longest Common Sequence）。 比如字符串1：BDCABA；字符串2：ABCBDAB 则这...
【刷题笔记】动态规划--字符串最少修改次数
Icanhearwawawa的博客
08-17 3029
字符串最少修改次数
【区间动态规划】1771. 由子序列构造的最长回文串的长度
闻缺陷则喜何志丹
06-27 915
给你两个字符串 word1 和 word2 ，请你按下述方法构造一个字符串： 从 word1 中选出某个 非空 子序列 subsequence1 。 从 word2 中选出某个 非空 子序列 subsequence2 。 连接两个子序列 subsequence1 + subsequence2 ，得到字符串。 返回可按上述方法构造的最长 回文串 的 长度 。如果无法构造回文串，返回 0 。 字符串 s 的一个 子序列 是通过从 s 中删除一些（也可能不删除）字符而不更改其余字符的顺序生成的字符串。 回文串 是
831.KMP字符串 做题笔记
m0_62615295的博客
04-18 1300
这是一个字符串匹配算法，对暴力的那种一一比对的方法进行了优化，使时间复杂度大大降低。举例来说，有一个字符串"BBCABCDABABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？许多算法可以完成这个任务，
003-5算法笔记【动态规划】习题3-17-字符串扩展距离
Wall_e_47的博客
05-01 714
题目 对于长度相同的两个字符串A和B,其距离定义为相应位置字符距离之和.两个非空格字符的距离是它们的ASCII编码之差的绝对值;空格与空格的距离为0,空格与其他字符的距离为一定值k. 在一般情况下,字符串A和B的长度不一定相同.字符串A的扩展是在A中插入若干空格字符所产生的字符串.在字符串A和B的所有长度相同的扩展中,有一对距离最小的扩展,该距离称为字符串A和B的扩展距离. 对于给定的字符串A和B,试计算其扩展距离. 输入 第1行是字符串A,第2行是字符串B,第3行是空格与其他字符的距离定值k. cmc s
541. 反转字符串 II（字符串）(Leetcode刷题笔记)
lunan的博客
02-06 498
541. 反转字符串 II（字符串）(Leetcode刷题笔记) 欢迎大家访问我的GitHub博客 https://lunan0320.cn 文章目录541. 反转字符串 II（字符串）(Leetcode刷题笔记)题目解题代码 C++算法效率 题目 给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。 如果剩余字符少于 k 个，则将剩余字符全部反转。 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
算法笔记 4.2 散列 字符串hash初步 例题
树叶子的博客
10-03 476
题目： 输入M:接下来输入M个字符串 输入N:接下来输入N个字符串 求N个字符串分别在M个字符串中出现的次数 字符串均为小写字母组成 长度不超过4 要求：不准遍历，每次查找时间复杂度O(1) 分析：字符串hash初步 转换为n进制数（字符串字符种类个数为n）,肯定能唯一表示 代码： #include&lt;iostream&gt; #include &lt;string&gt; usi...
3.动态规划.题目4
weixin_43831098的博客
07-21 975
个人根据代码随想录刷题的思路和笔记整理
字符串02 字符串大写转小写[C++]
weixin_42789937的博客
01-12 1180
本篇作为字符串的代码补充，提供了3种（差别并不大）解法以及函数的详细解释，供小伙伴们参考~🥝🥝
算法很美 笔记 5.字符串问题
xcsxchen
02-26 1425
5.字符串问题 题1:判定字符是否唯一 实现一个算法，确定一个字符串 s 的所有字符是否全都不同。 示例 1： 输入: s = “leetcode” 输出: false 示例 2： 输入: s = “abc” 输出: true 限制： 0 <= len(s) <= 100 如果你不使用额外的数据结构，会很加分。 public static boolean isUnique(String...
codeup《算法笔记》6.3题目A字符串处理题目编号1983全部测试样例和输出样例
01-24
《算法笔记》6.3小节——C++标准模板库(STL)介绍->string的常见用法详解A字符串处理题目编号1983全部测试样例和输出样例： 题目描述： 读入两个字符串，字符串除了数字还可能包括 '—'、'E'、'e'、'．'，相加之后...
LeetCode笔记-翻转字符串里的单词
12-21
【LeetCode笔记-翻转字符串里的单词】 在LeetCode中，第151题是“翻转字符串里的单词”，这是一道中等难度的问题。题目要求我们给定一个字符串，然后将这个字符串中的每个单词进行翻转，但保持单词内部的字符顺序...
c语言连接两个字符串maste开发笔记
06-18
本文将深入探讨如何在C语言中实现字符串连接，并提供相关的开发笔记。 首先，我们需要理解C语言中的字符串其实是由字符数组表示的，以空字符'\0'作为结束标志。因此，连接两个字符串实际上就是将一个字符串的字符...
javaWeb基础笔试题学习笔记
01-08
在题目描述的案例中，涉及到几个关键的字符串函数： 1. `substring(int indexStart, int indexEnd)`：这个函数用于从字符串中截取一部分子串。例如，`str.substring(1, 5)`应该返回"elco"，因为它是从索引1开始到...
《剑指Offer》刷题笔记——面试题46. 把数字翻译成字符串
12-22
一、题目描述： 二、解题分析： 1、剑指解析 2、代码实现 class Solution: def translateNum(self, num: int) -> int: if num9 and 10*num[-2]+num[-1]9 and 10*num[i]+num[i+1]<26: g = 1 else: g = 0 f...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 887
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 1562
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
打卡第22天------回溯算法
最新发布
GodLoveMe的博客
07-24 683
开始学习了，希望我可以尽快成功上岸！
力扣刷题笔记：动态规划与链表操作
"力扣500题刷题笔记2，包含C++代码实现，涉及动态规划、链表操作和双指针技术" 本资源主要涵盖了LeetCode中的三道经典问题，分别是力扣500题中的某一部分，包括杨辉三角II、移除链表元素和反转字符串中的单词III。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值