1.最长上升子序列
leetcode300
动态规划：对每一个元素进行遍历，每一个元素的代表以该元素结尾的子序列长度，只需要遍历全面的所有元素的最大值加一，便可以更新该dp数组，其中dp[i]的状态定义为在i位置结束处的最长上升子序列的长度，每个位置的长度初始化为1，需要遍历以i结尾处前面元素可能的最大长度；最后返回dp数组中的最大值就是最长子序列；
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int n = nums.size();
if(n==0)
return 0;
vector<int> dp(n);
for(int i=0; i<n; i++){
dp[i] = 1;
for(int j=0; j<i; j++){
if(nums[j]<nums[i]){
dp[i] = max(dp[i], dp[j]+1);
}
}
}
return *max_element(dp.begin(), dp.end());
}
};
2.最长公共子序列
leetcode1143
动态规划：定义一个二维dp[i][j]数组，状态定义为i和j分别为两个数组以其结尾的元素最长的公共元素个数，分两种情况讨论：
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
int m = text1.size();
int n = text2.size();
vector<vector<int>> dp(m+1, vector<int>(n+1));
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][n];
}
};
3.最长连续序列
leetcode128
哈希表：引入哈希表，为了快速查找某个元素是否存在；最长连续序列不断判断加一元素是否存在，同时需要判断前面一个元素是否存在，如果存在则没必要继续进行接下来的操作，因为长度一定小于前一个元素为起点的最长序列长度，此时的时间复杂度为O(n)，每个元素只遍历一遍；
class Solution {
public:
int longestConsecutive(vector<int>& nums) {
unordered_set<int> num_set;
for (const int& num : nums) {
num_set.insert(num);
}
int longestStreak = 0;
for (const int& num : num_set) {
if (!num_set.count(num - 1)) {
int currentNum = num;
int currentStreak = 1;
while (num_set.count(currentNum + 1)) {
currentNum += 1;
currentStreak += 1;
}
longestStreak = max(longestStreak, currentStreak);
}
}
return longestStreak;
}
};
4、最长回文子序列
leetcode：516
动态规划：定义一个二维dp[i][j]表示字符串区间从i到j内的最长回文串序列的长度，只有j>=i时，dp[i][j]的值才大于0，否则为0，分两种情况讨论：
状态转移方程：
dp[i][j] = dp[i+1][j-1] + 2; //i和j下标位置为相同元素时
dp[i][j] = max(dp[i+1][j], dp[i][j-1]); //i和j下标位置非相同元素时
从状态转移方程可以看出，每一个i坐标位置需要i+1位置的元素，因此顺序应为倒序遍历
class Solution {
public:
int longestPalindromeSubseq(string s) {
int n = s.length();
vector<vector<int>> dp(n, vector<int>(n));
for(int i=n-1; i>=0; i--){
dp[i][i] = 1;
for(int j=i+1; j<n; 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][n-1];
}
};
5.回文子串
leetcode647：
动态规划：与最长回文子序列思路相同，dp[i][j]表示以开头，以j结尾的元素是否是回文子串，如果是可以在其基础上继续增加，如果不是则需无法继续增加；初始化dp[i][i]的每个元素都是回文子串，状态转移方程是dp[i][j] = dp[i+1][j-1]，因此注意j是比i大的元素，并且求i的时候需要用到i+1，所以倒序遍历；
class Solution {
public:
int countSubstrings(string s) {
int n = s.size();
vector<vector<bool>> dp(n, vector<bool>(n, false));
int res = n;
for(int i=0; i<n; i++){
dp[i][i] = true;
}
for(int i=n-1; i>=0; i--){
for(int j=i+1; j<n; j++){
if(s[i]==s[j]){
if(j-i==1){
dp[i][j] = true;
res++;
}
else if(dp[i+1][j-1]){
dp[i][j] = true;
res++;
}
}
}
}
return res;
}
};
6.递增子序列
leetcode491:
回溯+哈希去重：考虑是遍历序列找到所有的递增子序列的问题，需要进行dfs,存在去开头元素的情况，因此需要考虑回溯法，对于不满足条件的情形进行剪枝操作，但是可能存在重复遍历的情形，需要对每层已经遍历的元素进行剪枝操作；
class Solution {
public:
vector<vector<int>> res;
void backTrack(vector<int> nums, vector<int> &temp, int k){
if(temp.size()>1){
res.push_back(temp);
}
int n = nums.size();
unordered_set<int> hash;
for(int i=k; i<n; i++){
if(hash.find(nums[i])!=hash.end() || (!temp.empty() && nums[i]<temp.back()))
continue; //剪枝
hash.insert(nums[i]); //哈希去重
temp.push_back(nums[i]);
backTrack(nums, temp, i+1);
temp.pop_back();
}
}
vector<vector<int>> findSubsequences(vector<int>& nums) {
vector<int> temp;
backTrack(nums, temp, 0);
return res;
}
};
7.排列序列
leetcode60
深度优先+剪枝：直接定位到递归排列的string数组的第k个元素所在的位置，同时对前面使用过的元素进行记录，用factriol函数来计算当去完当前元素时，剩余元素的递归个数，如果第k个元素在此递归中，则进入，不在的话需要对重新选取递归元素，并完成对k的重新计数（减去factriol的个数）；当把string填满长度为n时，记得到答案，可以返回。
string getPermutation(int n, int k) {
vector<bool> isUsed(n + 1, false); // 用于标记每个数是否用过
string res = ""; // 用于返回的结果排列序列
dfs(isUsed, res, n, k);
return res;
}
// 递归实现
void dfs(vector<bool> &isUsed, string &res, int n, int k){
int res_len = res.size();
if(res_len == n){ // 结束条件，当前排列已经结束
return;
}
int remain_fac = factorial(n - res_len - 1); // 剩下的数的全排列的个数
for(int i = 1; i <= n; ++i){ // 遍历 [1, n]
if(isUsed[i]){ // 跳过已使用的数
continue;
}
if(remain_fac > 0 && remain_fac < k){ // 剩下的数的全排列个数小于当前 k ，说明第 k 个排列肯定不在当前的递归子树中，直接跳过该递归
k -= remain_fac; // 剪枝
continue;
}
res = res + static_cast<char>('0' + i);
isUsed[i] = true;
dfs(isUsed, res, n, k);
// 因为是一次递归直接到叶子，所以不需要还原状态
}
}
// 求 n 的阶乘 或者直接使用数组：factorial = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880}
int factorial(int n){
int res = 1;
while(n > 0){
res *= n;
n--;
}
return res;
}
8.不同的子序列
leetcode115：
动态规划：定义dp[i][j]表示t的第i个元素，s的第j个元素时，s的子序列中t出现的次数；状态转移方程：如果两字符串当前遍历的元素相等，则当前dp出现的次数为t的前i-1个和s的前j-1个加上i不变时，j-1位置出现的次数；如果当前元素不相等，那么必须舍弃当前元素，为t的第i个和j-1个元素出现的次数；
注意：边界条件为dp[0][i] = 1，表示每个位置的s元素包含0个t元素时个数为1个；
class Solution {
public:
int numDistinct(string s, string t) {
int m = s.size();
int n = t.size();
vector<vector<long long>> dp(n+1, vector<long long>(m+1));
for(int i=0; i<m; i++){
dp[0][i] = 1;
}
for(int j=1; j<=m; j++){
for(int i=1; i<=n; i++){
if(t[i-1]==s[j-1]){
dp[i][j] = dp[i-1][j-1] + dp[i][j-1];
}
else{
dp[i][j] = dp[i][j-1];
}
}
}
return dp[n][m];
}
};
9.编辑距离
leetcode72：
动态规划：状态dp[i][j]表示word1的前i个元素转换为word2的前j各元素时所需的最小替换次数；当word1[i-1]==word2[j-1]时，dp[i][j]为dp[i-1][j-]的操作次数，即不需要对当前元素进行操作，只有需要操作前面即可；如果当前元素不相等，需要对其进行增dp[i][j-1]、删dp[i-1][j]、改dp[i-1][j-1]当中最小的操作次数加一；
边界条件： dp[i][0] = i;表示word1的i个元素全删除才能变为word2的零个元素
dp[0][i] = i;表示word1的0个元素需要增加i个元素才能变为word2
class Solution {
public:
int minDistance(string word1, string word2) {
int m = word1.size();
int n = word2.size();
vector<vector<int>> dp(m+1, vector<int>(n+1));
for(int i=1; i<=m; i++)
dp[i][0] = i;
for(int i=1; i<=n; i++)
dp[0][i] = i;
for(int i=1; i<=m; i++){
for(int j=1; j<=n; j++){
if(word1[i-1]==word2[j-1])
dp[i][j] = dp[i-1][j-1];
else
dp[i][j] = min({dp[i-1][j]+1, dp[i-1][j-1]+1, dp[i][j-1]+1}); //删、替、增
}
}
return dp[m][n];
}
};
279
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
