Journey of LeetCode|DAY 49
Preface
This is a new day to continue my Dynamic Programming journey.
Learn something new and keep reviewing what I learnt before.
1. Palindromic Substrings
LeetCode Link: 647. Palindromic Substrings
Given a string s, return the number of palindromic substrings in it.
A string is a palindrome when it reads the same backward as forward.
A substring is a contiguous sequence of characters within the string.
Example 1:
Input: s = “abc”
Output: 3
Explanation: Three palindromic strings: “a”, “b”, “c”.
Example 2:
Input: s = “aaa”
Output: 6
Explanation: Six palindromic strings: “a”, “a”, “a”, “aa”, “aa”, “aaa”.
Constraints:
1 <= s.length <= 1000
s consists of lowercase English letters.
Analysis and Solution
Dynamic Programming
LeetCode C++ as followings Dynamic Programming
class Solution {
public:
int countSubstrings(string s) {
vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
int result = 0;
for (int i = s.size() - 1; i >= 0; i--) { // traverse clos firstly ,then rows
for (int j = i; j < s.size(); j++) {
if (s[i] == s[j]) {
if (j - i <= 1) { // case 1: i = j,"a"; case 2: j - i < = 1 , "aa"
result++;
dp[i][j] = true;
} else if (dp[i + 1][j - 1]) { // case 3: "abcba"
result++;
dp[i][j] = true;
}
}
}
}
return result;
}
};
2. Longest Palindromic Subsequence
LeetCode Link: 516. Longest Palindromic Subsequence
Given a string s, find the longest palindromic subsequence’s length in s.
A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.
Example 1:
Input: s = “bbbab”
Output: 4
Explanation: One possible longest palindromic subsequence is “bbbb”.
Example 2:
Input: s = “cbbd”
Output: 2
Explanation: One possible longest palindromic subsequence is “bb”.
Constraints:
1 <= s.length <= 1000
s consists only of lowercase English letters.
Analysis and Solution
Dynamic Programming
LeetCode C++ as followings Dynamic Programming
class Solution {
public:
int longestPalindromeSubseq(string s) {
vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
for (int i = 0; i < s.size(); i++) dp[i][i] = 1;//initialization
for (int i = s.size() - 1; i >= 0; i--) {//traverse cols firstly
for (int j = i + 1; j < s.size(); j++) {//then rows
if (s[i] == s[j]) {
dp[i][j] = dp[i + 1][j - 1] + 2;//recursive formula
} else {
dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
}
}
}
return dp[0][s.size() - 1];
}
};