【七十三】【算法分析与设计】516. 最长回文子序列,二叉树,329. 矩阵中的最长递增路径,记忆化递归填表

最新推荐文章于 2024-05-13 21:32:22 发布

妖精七七_

最新推荐文章于 2024-05-13 21:32:22 发布

阅读量754

点赞数 11

分类专栏：算法设计与分析文章标签：算法 c++ 数据结构

本文链接：https://blog.csdn.net/m0_74163972/article/details/138312154

版权

算法设计与分析专栏收录该内容

90 篇文章 1 订阅

订阅专栏

516. 最长回文子序列

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

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

示例 1：

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

示例 2：

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

提示：

1 <= s.length <= 1000

s 仅由小写英文字母组成

回文串子序列.

[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]).

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

边界情况,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，说明越界了，返回0
            dp[i][j] = 0; // 将dp[i][j]置为0
            return dp[i][j]; // 返回0
        }
        if (i == j) { // 如果i等于j，说明只有一个字符，是回文子序列，返回1
            dp[i][j] = 1; // 将dp[i][j]置为1
            return 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; // 将输入字符串赋值给成员变量s
        solveinit(); // 初始化
        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

复制

集合,拿一个元素当作是头节点,还剩下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，返回1
        dp[n][m] = 1;
        return dp[n][m];
    }
    if (m == 0) { // 如果高度为0，返回0
        dp[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搜索

暴力递归搜索,超时.

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; // 初始化最长递增路径长度为0
        n=mat.size(); // 获取矩阵的行数
        m=mat[0].size(); // 获取矩阵的列数
    }

    // 深度优先搜索函数，用于寻找最长递增路径
    void dfs(int i,int j){
        path++; // 当前路径长度加1
        ret=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; // 将输入矩阵赋值给成员变量mat
        solveinit(); // 初始化
        for(int i=0;i<n;i++){ // 遍历矩阵中的每一个位置
            for(int j=0;j<m;j++){
                path=0; // 初始化路径长度为0
                dfs(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; // 初始化最长递增路径长度为0
        n = 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; // 初始化当前位置的最长递增路径长度为0
            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]){ // 如果下一个位置合法且值大于当前位置
                    ans=max(ans,dfs(x,y)); // 更新最长递增路径长度
                }
            }
        }
        dp[i][j]=ans+1; // 缓存结果
        return dp[i][j]; // 返回当前位置的最长递增路径长度
    }

    // 主函数，找出最长递增路径的长度
    int longestIncreasingPath(vector<vector<int>>& _matrix) {
        mat = _matrix; // 将输入矩阵赋值给成员变量mat
        solveinit(); // 初始化
        for (int i = 0; i < n; i++) { // 遍历矩阵中的每一个位置
            for (int j = 0; j < m; j++) {
                ret=max(ret,dfs(i, j)); // 计算从当前位置出发的最长递增路径长度
            }
        }
        return ret; // 返回最长递增路径的长度
    }
};

结尾

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

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

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

妖精七七_

关注

11
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
【七十三】【算法分析与设计】516. 最长回文子序列,二叉树,329. 矩阵中的最长递增路径,记忆化递归填表

给你一个字符串s，找出其中最长的回文子序列，并返回该序列的长度。子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。4一个可能的最长回文子序列为 "bbbb"。s = "cbbd"2一个可能的最长回文子序列为 "bb"。仅由小写英文字母组成1.回文串子序列.[i,j]区间最长回文子序列,如果s[i]==s[j],dp[i][j]=dp[i+1][j-1].如果s[i]!2.利用记忆化递归填表,可以很快处理边界,不需要考虑填表顺序.
复制链接

扫一扫