516. 最长回文子序列

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

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

示例 1：

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

示例 2：

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

提示：

• 1 <= s.length <= 1000

• s 仅由小写英文字母组成

1.

回文串子序列.

[i,j]区间最长回文子序列,如果s[i]==s[j],dp[i][j]=dp[i+1][j-1].

如果s[i]!=s[j],dp[i][j]=max(dp[i+1][j],dp[i][j-1]).

2.

利用记忆化递归填表,可以很快处理边界,不需要考虑填表顺序.

边界情况,i==j时,renturn 1.

i>j时,return 0.

class Solution {
public:string s;               // 储存输入字符串int n;                  // 字符串长度vector<vector<int>> dp; // 动态规划数组，dp[i][j]表示从第i到第j个字符之间的最长回文子序列长度void solveinit() {n = s.size(); // 获取字符串长度dp.clear(); // 清空动态规划数组dp.resize(n, vector<int>(n, -1)); // 初始化动态规划数组，全部置为-1}int dfs(int i, int j) { // 递归函数，用于计算从第i到第j个字符之间的最长回文子序列长度if (i > j) { // 如果i大于j，说明越界了，返回0dp[i][j] = 0; // 将dp[i][j]置为0return dp[i][j]; // 返回0}if (i == j) { // 如果i等于j，说明只有一个字符，是回文子序列，返回1dp[i][j] = 1; // 将dp[i][j]置为1return dp[i][j]; // 返回1}if (dp[i][j] != -1) // 如果dp[i][j]不为-1，说明已经计算过，直接返回结果return dp[i][j]; // 返回dp[i][j]if (s[i] == s[j]) { // 如果第i个字符和第j个字符相同dp[i][j] = dfs(i + 1, j - 1) + 2; // 则最长回文子序列长度等于去掉两端字符后的子序列长度加2} else { // 如果第i个字符和第j个字符不相同dp[i][j] = max(dfs(i, j - 1), dfs(i + 1, j)); // 则最长回文子序列长度等于去掉第i个字符后的子序列长度和去掉第j个字符后的子序列长度的最大值}return dp[i][j]; // 返回dp[i][j]}int longestPalindromeSubseq(string _s) { // 主函数，求最长回文子序列的长度s = _s; // 将输入字符串赋值给成员变量ssolveinit(); // 初始化for (int i = 0; i < n; i++) { // 遍历字符串的所有子序列for (int j = i; j < n; j++) {dfs(i, j); // 计算从第i到第j个字符之间的最长回文子序列长度}}return dp[0][n - 1]; // 返回整个字符串的最长回文子序列长度}
};

二叉树

描述

小强现在有nn个节点,他想请你帮他计算出有多少种不同的二叉树满足节点个数为nn且树的高度不超过mm的方案.因为答案很大,所以答案需要模上1e9+7后输出. 树的高度: 定义为所有叶子到根路径上节点个数的最大值.

例如: 当n=3,m=3时,有如下5种方案:

数据范围：1\le n,m\le 50\1≤n,m≤50

进阶：时间复杂度O(mn^2)\O(mn2) ，空间复杂度O(nm)\O(nm)

输入描述：

第一行输入两个正整数nn和mm. 1\leq m \leq n \leq 501≤m≤n≤50

输出描述：

输出一个答案表示方案数.

示例1

输入：

3 3

复制

输出：

5

复制

示例2

输入：

3 2

复制

输出：

1

复制

示例3

输入：

4 3

复制

输出：

6

复制

1.

集合,拿一个元素当作是头节点,还剩下n-1个节点,枚举左边节点数量,分布乘法.

#if 1#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using p = pair<ll, ll>;
int dx[] = { 1, -1, 0, 0 }; // 定义上下左右四个方向的增量数组
int dy[] = { 0, 0, 1, -1 }; //
const int  MOD = 1e9 + 7; // 取模值// 输入参数变量
int n, m;
// 存储输入变量// 自定义变量
vector<vector<ll>> dp; // 动态规划数组，dp[i][j]表示节点数为i，高度不超过j的方案数// 输入参数+存储输入变量
void init() {}// 初始化自定义变量
void solveinit() {dp.clear(); // 清空动态规划数组dp.resize(n + 1, vector<ll>(m + 1, -1)); // 初始化动态规划数组，全部置为-1
}// 计算方案数的递归函数
ll dfs(int n, int m) {if (n == 0) { // 如果节点数为0，返回1dp[n][m] = 1;return dp[n][m];}if (m == 0) { // 如果高度为0，返回0dp[n][m] = 0;return dp[n][m];}if (dp[n][m] != -1) return dp[n][m]; // 如果已经计算过，直接返回结果ll ans = 0;for (int i = 0; i < n; i++) { // 遍历左子树节点数ans = (ans + (dfs(i, m - 1) * dfs(n - 1 - i, m - 1) % MOD)) % MOD; // 计算方案数并取模}dp[n][m] = ans % MOD; // 缓存结果return dp[n][m];
}// 解决问题
void solve() {solveinit(); // 初始化cout << dfs(n, m) << endl; // 输出方案数
}int main() {ios::sync_with_stdio(false);cin.tie(nullptr);while (cin >> n >> m) { // 循环读入数据init(); // 输入参数处理solve(); // 解决问题}
}#endif // 1

329. 矩阵中的最长递增路径

给定一个 m x n 整数矩阵 matrix ，找出其中 最长递增路径 的长度。

对于每个单元格，你可以往上，下，左，右四个方向移动。 你 不能 在 对角线 方向上移动或移动到 边界外（即不允许环绕）。

示例 1：

输入：matrix = [[9,9,4],[6,6,8],[2,1,1]] 输出：4 解释：最长递增路径为 [1, 2, 6, 9]。

示例 2：

输入：matrix = [[3,4,5],[3,2,6],[2,2,1]] 输出：4 解释：最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。

示例 3：

输入：matrix = [[1]] 输出：1

提示：

• m == matrix.length

• n == matrix[i].length

• 1 <= m, n <= 200

• 0 <= matrix[i][j] <= 2(31)1

暴力dfs搜索

1.

暴力递归搜索,超时.

class Solution {
public:vector<vector<int>> mat; // 存储输入矩阵int ret; // 最长递增路径的长度int path; // 当前路径长度int dx[4]={1,-1,0,0}; // 定义四个方向的增量数组int dy[4]={0,0,1,-1}; //int n,m; // 矩阵的行数和列数// 初始化函数void solveinit() {ret=0; // 初始化最长递增路径长度为0n=mat.size(); // 获取矩阵的行数m=mat[0].size(); // 获取矩阵的列数}// 深度优先搜索函数，用于寻找最长递增路径void dfs(int i,int j){path++; // 当前路径长度加1ret=max(ret,path); // 更新最长递增路径长度for(int k=0; k < 4; k++){ // 遍历四个方向int x=i+dx[k]; // 计算下一个位置的行坐标int y=j+dy[k]; // 计算下一个位置的列坐标if(x>=0 && x<n && y>=0 && y<m && mat[x][y]>mat[i][j]){ // 如果下一个位置合法且值大于当前位置dfs(x,y); // 继续搜索}}path--; // 回溯，当前路径长度减1}// 主函数，找出最长递增路径的长度int longestIncreasingPath(vector<vector<int>>& _matrix) {mat = _matrix; // 将输入矩阵赋值给成员变量matsolveinit(); // 初始化for(int i=0;i<n;i++){ // 遍历矩阵中的每一个位置for(int j=0;j<m;j++){path=0; // 初始化路径长度为0dfs(i,j); // 从当前位置开始深度优先搜索}}return ret; // 返回最长递增路径的长度}
};

记忆化递归填dp表

class Solution {
public:vector<vector<int>> mat; // 存储输入矩阵int ret; // 最长递增路径的长度int path; // 当前路径长度int dx[4] = {1, -1, 0, 0}; // 定义四个方向的增量数组int dy[4] = {0, 0, 1, -1}; //int n, m; // 矩阵的行数和列数vector<vector<int>> dp; // 动态规划数组，dp[i][j]表示从位置(i,j)出发的最长递增路径长度// 初始化函数void solveinit() {ret = 0; // 初始化最长递增路径长度为0n = mat.size(); // 获取矩阵的行数m = mat[0].size(); // 获取矩阵的列数dp.clear(); // 清空动态规划数组dp.resize(n,vector<int>(m,-1)); // 初始化动态规划数组，全部置为-1}// 深度优先搜索函数，用于寻找最长递增路径int dfs(int i, int j) {if(dp[i][j]!=-1) return dp[i][j]; // 如果已经计算过，直接返回结果int ans=0; // 初始化当前位置的最长递增路径长度为0for(int k=0; k < 4; k++){ // 遍历四个方向int x=i+dx[k]; // 计算下一个位置的行坐标int y=j+dy[k]; // 计算下一个位置的列坐标if(x>=0 && x<n && y>=0 && y<m && mat[x][y]>mat[i][j]){ // 如果下一个位置合法且值大于当前位置ans=max(ans,dfs(x,y)); // 更新最长递增路径长度}}}dp[i][j]=ans+1; // 缓存结果return dp[i][j]; // 返回当前位置的最长递增路径长度}// 主函数，找出最长递增路径的长度int longestIncreasingPath(vector<vector<int>>& _matrix) {mat = _matrix; // 将输入矩阵赋值给成员变量matsolveinit(); // 初始化for (int i = 0; i < n; i++) { // 遍历矩阵中的每一个位置for (int j = 0; j < m; j++) {ret=max(ret,dfs(i, j)); // 计算从当前位置出发的最长递增路径长度}}return ret; // 返回最长递增路径的长度}
};

结尾

最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。

同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。

谢谢您的支持，期待与您在下一篇文章中再次相遇！