记忆化搜索

记忆化搜索是一种优化递归算法的方法，通过将已经计算过的子问题的结果存储起来（通常使用哈希表或数组），避免重复计算相同的子问题。
本质上是通过缓存中间结果来减少计算的重复性。

动态规划

动态规划是通过将问题分解成子问题来解决的，它通常通过表格化的方式（自底向上）来存储子问题的解，以便在需要时能够快速访问。
动态规划的核心思想是通过自底向上的方式来解决问题，通常使用一个数组或表格来存储每个子问题的解，从而避免了递归的重复计算。

二者区别与联系

记忆化搜索和动态规划的区别，主要在于计算的顺序。
记忆化搜索通常是自顶向下的递归方式，在递归中检查子问题是否已经计算过，并存储结果。
动态规划通常是自底向上的方式，逐步计算所有子问题，并存储所有的中间结果，最终得到问题的解。
两者的时间复杂度是相同的，都是 O(n)，因为两者都避免了重复计算子问题。

例题

最长回文子串 -力扣

记忆化搜索解答：

class Solution {
public:int dp[1000][1000];std::string ss;bool judge(int l, int r) {if (dp[l][r] != -1) {return dp[l][r];}if (ss[l] == ss[r]) {if (r - l > 1) {if (dp[l + 1][r - 1] == -1) {dp[l][r] = judge(l + 1, r - 1);} else {dp[l][r] = dp[l + 1][r - 1];}} else {dp[l][r] = 1;}} else {dp[l][r] = 0;}return dp[l][r];}std::string longestPalindrome(std::string s) {memset(dp,-1,sizeof(dp));int len = s.length();ss = s;int res = 0;int l = 0;for (int i = 0; i < len; i++) {for (int j = i; j < len; j++) {dp[i][j] = judge(i, j);if (dp[i][j] == 1 && j - i > res) {res = j - i;l = i;}}}return s.substr(l, res + 1);}
};

动态规划解答

class Solution {
public:std::string longestPalindrome(std::string s) {int len = s.length();bool dp[1000][1000];memset(dp,false,sizeof(dp));for(int i = len - 1; i >= 0; i--){for(int j = i; j < len; j++){if(s[i] != s[j]){dp[i][j] = false;}else{if(i == j){dp[i][j] = true;}else{if(j - i == 1){dp[i][j] = true;}else{dp[i][j] = dp[i+1][j-1];}}}}}int res = 0;int l = 0;for(int i = 0; i < len; i++){for(int j = i; j < len; j++){if(dp[i][j] == true){if(res < j - i){res = j - i;l = i;}}}}return s.substr(l,res + 1);}};

由于函数调用的原因，使用递归的记忆化搜索算法的时间会稍微久一点