LeetCode 91 - 100

最新推荐文章于 2024-07-25 21:13:04 发布
最新推荐文章于 2024-07-25 21:13:04 发布
阅读量117 收藏
点赞数
分类专栏： AcWing Leetcode 究极班 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/esjiang/article/details/114258111
版权

LeetCode 91. 解码方法

分析

有点类似于编辑距离问题, 所以考虑编辑距离合法的情况, 用dp去分析
合法的情况是指12可以看成了两个数1和2或者12
注意,
f[i] 既可以从f[i - 1]转化过来, 也可以从f[i - 2]转化过来
还需要注意什么时候能从f[i - 1]和f[i - 2]转化过来
在这里插入图片描述

代码

class Solution {
public:
    int numDecodings(string s) {
        int n = s.size();
        s = ' ' + s;
        vector<int> f(n + 1);
        f[0] = 1;
        for (int i = 1; i <= n; i ++ ){
            if (s[i] >= '1' && s[i] <= '9')  f[i] += f[i - 1];
            // 当可以从f[i - 2]转化过来的时候, i > 1
            if  (i > 1){
                int t = (s[i - 1] - '0') * 10 + (s[i] - '0');
                if (t >= 10 && t <= 26) f[i] += f[i - 2];
            }
        }
        return f[n];
    }
};

LeetCode 92. 反转链表 II

分析

直接画图, 即可, 注意最后一步链表节点指向的时候, 先做后面节点的指向, 再做前面节点的指向
在这里插入图片描述

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        auto dummy = new ListNode(-1);
        dummy->next = head;

        auto a = dummy;
        for (int i = 0; i < m - 1; i ++ ) a = a->next;
        auto b = a->next, c = b->next;
        for (int i = 0; i < n - m; i ++ ){
            auto t = c->next;
            c->next = b;
            b = c, c = t;
        }
        a->next->next = c;
        a->next = b;
        return dummy->next;
    }
};

LeetCode 93. 复原IP地址

分析

直接用递归去解决, 注意递归中要传入参数, 遍历到第几个位置u, 以及当前完成了分隔.的数目k, 还需要考虑 前导0 , 以及已经有4个分隔的剪枝

代码

class Solution {
public:
    vector<string> ans;
    vector<string> restoreIpAddresses(string s) {
        dfs(s, 0, 0, "");// 2. 表示遍历到第几个位置, 3.表示完成了几个分隔 4. 当前已经完成的字符串
        return ans;
    }

    void dfs(string&s, int u, int k, string path){
        if (u == s.size()){
            if (k == 4){
                path.pop_back();
                ans.push_back(path);
            }
            return;
        }
        if (k == 4) return ; // 剪枝, 已经分隔4个了, 直接退出 , 比如11111111111111111111 就会超时
        for (int i = u, t = 0; i < s.size(); i ++ ){
            if (i > u && s[u] == '0') break; // s[u] == '0' 前导0 说明此分支不合法
            // i > u是因为 0000 可以转化为0.0.0.0合法, 所以i == u 的时候 s[u] = 0是合法的.
            t = t * 10 + s[i] - '0';
            if (t <= 255) dfs(s, i + 1, k + 1, path + to_string(t) + '.');
            else break;
        }
    }
};

LeetCode 94. 二叉树的中序遍历

分析

先看前序遍历
再见自己写的这篇文章模拟一遍

每次当前节点不空, 则遍历左子树
while循环借宿
然后回到到根节点, 即栈顶元素, 遍历根节点
然后到右子树看看

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        while (root || stk.size()){
            while (root){ // 当前节点不空, 先遍历左子树
                stk.push(root);
                root = root->left;
            }
            // 左子树遍历完成, 回溯到根节点, 即栈顶元素就是根节点
            root = stk.top(); stk.pop();
            res.push_back(root->val); // 遍历根节点
            root = root->right; // 到右子树看看
        }
        return res;
    }
};

LeetCode 95. 不同的二叉搜索树 II

分析

在1 ~ n中递归的建树, 由于1 ~ n 已经是排好序的数列, 所以 任何一个片段[l, r]都是一个二叉搜索树, 因此递归建立左子树 和递归建立右子树即可, 每次递归返回已经建好的树的根节点
dfs(l, r)表示在区间[l, r]之间建好树
因为任何的左子树情况 都可以和任何右子树的情况 合并称为一种情况, 因此是乘法原理.
res是根节点的集合.
在这里插入图片描述

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        return dfs(1, n);
    }
    vector<TreeNode*> dfs(int l, int r){
        if (l > r) return {NULL};
        vector<TreeNode*> res;
        for (int i = l; i <= r; i ++ ){
            auto left = dfs(l, i - 1), right = dfs(i + 1, r);
            // 此时计算出的left是[l, i - 1]形成的森林(很多树)的所有根节点的集合.
            // 乘法原理
            for (auto l : left) 
                for (auto r : right){
                    auto root = new TreeNode(i);
                    root->left = l, root->right = r;
                    res.push_back(root);
                }
        }
        return res;
    }
};

LeetCode 96. 不同的二叉搜索树

分析

类似上一题, 先枚举区间长度i, 在枚举间隔j, 用乘法原理
f[i] += f[j - 1] * f[i - j]

代码

class Solution {
public:
    int numTrees(int n) {
        vector<int> f(n + 1);
        f[0] = 1;
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= i; j ++ )
                f[i] += f[j - 1] * f[i - j];
        return f[n];
    }
};

LeetCode 97. 交错字符串

分析

类似dp编辑距离去分析, 注意要剪枝, s3.size() != n + m的时候需要剪枝
在这里插入图片描述

代码

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int n = s1.size(), m = s2.size();
        if (s3.size() != n + m) return false; 
        // 注意不能与下面这句话交换顺序, 否则s3.size() 多了
        s1 = ' ' + s1, s2 = ' ' + s2, s3 = ' ' + s3;

        vector<vector<bool>> f(n + 1, vector<bool>(m + 1));
        // 注意从0开始循环, 因为可以s1 一个字符也不取, 或者s2一个也不取
        // 否则,从1开始会漏掉上面的情况.
        for (int i = 0; i <= n; i ++ )        
            for (int j = 0; j <= m; j ++ ){
                if (!i && !j) f[i][j] = true;
                else {
                    if (i && s1[i] == s3[i + j]) f[i][j] = f[i - 1][j];
                    if (j && s2[j] == s3[i + j]) f[i][j] = f[i][j] || f[i][j - 1];
                }
            }
        return f[n][m];
    }
};

LeetCode 98. 验证二叉搜索树

分析

按照定义来判断, 左子树的最大值是否大于当前节点的值, 右子树的最小值是否小于当前节点的值
遍历的时候, 求下最小值和最大值

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if (!root) return true;
        return dfs(root)[0];
    }
    vector<int> dfs(TreeNode* root){
        vector<int> res({1, root->val, root->val}); //  1. 当前整棵树是否符合定义 2. 左子树的最大值, 3. 右子树的最小值
        if (root->left){
            auto t = dfs(root->left); // 递归左子树的情况
            // 如果左子树不合法  
            // 或者 左子树中最大值 大于等于 当前根节点的值 也不合法
            if (!t[0] || t[2] >= root->val) res[0] = 0; 
            res[1] = min(res[1], t[1]);
            res[2] = max(res[2], t[2]);
        }
        if (root->right){
            auto t = dfs(root->right);
            if (!t[0] || t[1] <= root->val) res[0] = 0;
            res[1] = min(res[1], t[1]);
            res[2] = max(res[2], t[2]);
        }
        return res;
    }
};

code(更简单的做法)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        return dfs(root, nullptr, nullptr);
    }
    bool dfs(TreeNode* root, int* minn, int* maxx) {
        if (!root) return true;
        if (minn != nullptr && root->val <= *minn) return false;
        if (maxx != nullptr && root->val >= *maxx) return false;
        return dfs(root->left, minn, &root->val) && dfs(root->right, &root->val, maxx);
    }
};

LeetCode 99. 恢复二叉搜索树

分析

如何判断, 哪两个数被交换了
如果交换的是相邻两个数, 那么直接找逆序对即可
如果交换的不是相邻两个数, 可以发现交换的是第一个逆序对的第一个数 和第二个逆序对的第二个数
在这里插入图片描述
因此, 中序遍历输出, 找出错误的逆序对, 就可以找到这两个数

注意题目要求
进阶：使用 O(n) 空间复杂度的解法很容易实现。你能想出一个只使用常数空间的解决方案吗？

Morris遍历(常数空间)

参考yxc题解
可以在当前点的前驱节点连一根线索, 方便回溯.
主要步骤, 从根节点开始遍历,
1.如果没有左子树, 遍历当前点, 进入右子树
2.如果有左子树, 找到当前的前驱节点, 找到前驱节点后, 我们需要判断 我们是从当前点的上方下来的, 还是从 前驱节点通过红色线索上去的.
(1) 如果前驱节点的右儿子是空的, 说明左子树还没遍历, 我们是从上面下来的, 则进入左子树, 并将前驱节点的右儿子置为当前点.
(2)如果前驱节点的右儿子是当前点, 说明我们是从前驱节点上来的, 左子树已经被遍历过, 则将前驱节点线索 清空, 打印当前点的值, 然后进入右子树继续遍历.
在这里插入图片描述
在这里插入图片描述

morris 时间复杂度 O(n)

因为在寻找前驱节点的时候, 当前根节点所连的边必定会被搜1次, 有n个点, 所以搜了n次

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void recoverTree(TreeNode* root) {
        TreeNode* first = NULL, *second, *prep = NULL;
        while (root){
            if (!root->left){
                // 如果没有左子树 遍历当前点
                if (prep && prep->val > root->val){
                    if (!first) first = prep, second = root;
                    else second = root;
                }
                // 进入到右子树
                prep = root;
                root = root->right;
            }
            else {
                TreeNode* p = root->left;
                while (p->right && p->right != root) p = p->right;
                if (!p->right){ // 前驱节点还没连到当前点, 说明是从上面下来的   
                    p->right = root; // 连到当前点, 方便回溯
                    root = root->left; // 遍历左子树
                }
                else { // 否则, 是从下面上去的
                    p->right = NULL; // 清除线索
                    // 遍历当前点
                    if (prep && prep->val > root->val){
                        if (!first) first = prep, second = root;
                        else second = root;
                    }
                    prep = root;
                    root = root->right;
                }
            }
        }
        swap(first->val, second->val);
    }
};

代码(简单做法)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void recoverTree(TreeNode* root) {
        dfs(root);
        swap(first->val, second->val);
    }
    TreeNode* first, *second, *prev;
    void dfs(TreeNode* root){
        if (!root) return ;
        dfs(root->left);
        if (prev && prev->val > root->val){
            if (!first )first = prev, second = root;
            else second = root;
        }
        prev = root; // 一定要加这句话
        dfs(root->right);
    }
};

LeetCode 100. 相同的树

分析

直接递归做即可
注意 p->val != q->val 可以和(!p && q || p && !q) 放在一起

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if (!p && !q) return true;
        else if (!p && q || !q && p || p->val != q->val) return false;
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }

};
打雷要下雨，雷欧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Code_100_Python_Projects:通过自己编写样式编写100个项目来编写和学习Python
03-21
100天的Python挑战 在此仓库中，我尝试按照自己的风格编写一个一百个项目，包括网站，游戏，应用程序以及抓取和数据科学，以将python添加到我的知识堆栈中：） 我感谢这门很棒的课程帮助我深入学习python： ： 包含项目的文件夹有4种类型： 初学者项目 中级项目 高级项目 专业项目 如果您有更好的主意/风格，或者您想解决某些问题，请做出贡献。我是一个学习速度很快的人，并且想向您学习：)
leetcode题库-leetcode-pp-node:leetcode-pp-node
06-29
leetcode题库 leetcode-pp-node 官网后端。 使用 koa2 结合 Github Actions 开发。目前采用静态 JSON 存放题解，讲义，用户信息等数据，后期使用数据库承载内容。 TODOS 在 91 网站直接提交代码到力扣中，获取执行...
mui HTML5+ 微信授权登录 出现code: -100, message: send, innerCode: -6
热门推荐
斗战圣佛91的博客
06-15 1万+
注意，微信开放平台申请的移动应用： 应用签名：  错误的：CC:2B:D6:D8:45:07:70:89:11:BD:E4:BA:69:57:74:87  正确的：cc2bd6d84507708911bde4ba69577487 包名：com.chinamcr.happybuy 在打包前确认：  1、确认申请时填写的应用签名和安装的应用签名是否一致  2、确认
LeetCode HOT-100 分类总结
wang_luwei的博客
03-26 1066
LeetCode HOT-100 分类总结
leetcode91-解码方法
Zack_zc_zc的博客
09-15 257
一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：‘A’ -> “1”‘B’ -> “2”…要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。注意，消息不能分组为 (1 11 06) ，因为 “06” 不能映射为 “F” ，这是由于 “6” 和 “06” 在映射中并不等价。给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数。题目数据保证答案肯定是一个 32 位 的整数。示例 1：输入：s = “12”输出：2。
LeetCode-91-解码方法
L.Wzz的博客
12-23 1116
我们可以使用动态规划法来解决本问题。我们利用数组dp[i]来记录字符串前i位能够组成的解码方法总数。在设计状态转移方程时，我们需要注意这样子的特殊情况：1、当s[i]不为0时，单独一个s[i]肯定能够被解码，故此时dp[i]+=dp[i−1]，表示前i−1位的解码方法可以被继承；2、当s[i−1]不为0，且s[i]和s[i−1]构成的数字可以被解码时，当前位置还可以继承前i−2位的解码方法，故dp[i。
leetcode中国-awesome-java-leetcode-1:awesome-java-leetcode-1
06-29
leetcode中国 awesome-java-leetcode 我如今是一名 Android Developer，大学的我曾是一名 ACMer，我一直认为数据...78,79,80,85,88,90,91,98,102,117,121,125,127,128,133,139,146,157,158,161 168,173,200,206,208,20
leetcode2-leetcode-python-:一些实用的脚本工具及之前的leetcode算法题
06-29
leetcode 2 leetcode-python- python基础巩固以及leetcode刷题代码 菜鸟学习日记 在leetcode上面刷的一些算法题，还有一些Python基础语法的复习，持续更新。。。...91. 92. 93. 94. 95. 96. 97. 98.
leetcode316-leetcode:leetcode
06-30
91-100题 011: 101-110题 012: 111-120题 013: 121-130题 014: 131-140题 015: 141-155, 160 016: 162-169 017: 171-174, 179 018: 187-190 019: 191, 198-200 020: 201-210 021: 211-220 022: 221-230 023: 231-240...
leetcode530-leetcode-practise:用python学习leetcode
06-30
leetcode 530 leetcode-练习 用python学习leetcode 分而治之 95, 96, 241, 91, 247 评论：241, 95, 91, 96,247 回溯 39、50、113、112、46、90、77 动态规划 最长子串leetcode 1143，切割钢片线性模型，0-1背包...
算法-KMP字符串匹配
xx_xb的博客
07-23 180
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
【LeetCode】141.环形链表、142. 环形链表 II（算法 + 图解）
最新发布
明志の博客
07-25 878
环形链表
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 662
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 763
二叉搜索树向左或向右指明方向，不用遍历整个树。
数据结构与算法--【数组2】力扣练习 || 双指针 / 移除元素 / 数组排序
qq_44578108的博客
07-25 524
简单删除元素 / 指定某元素位置，其余元素位置相对不变双指针指向数组头。快指针扫描数组并判断，慢指针收集变化后的数组元素。不创建新数组，只覆盖原数组。对数组元素排序一个指针指开头，一个指针指结尾。判断两指针指向值大小，循环结束条件first <= last；for循环，while循环均可，本人更习惯while循环。使用malloc为新数组分配空间，注意，创建了新数组。
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 670
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
python基础知识点（蓝桥杯python科目个人复习计划73）
m0_73523976的博客
07-25 141
（1）100万元正好被分成若干份，不能有剩余。1 <= |s| <= 5 * 10^5,保证s只包含大写字母、小写字母和数字。地产大佬先生临终的遗愿是拿出100万元给x社区的居民抽奖。1 <= |s| <= 10^6，保证s只包含大小写字母。给定一个长度为n的字符串s，请你判断字符串s是否回文。（3）在满足上述条件的情况下，分成的份数越多越好。给定一个字符串s，请你求出s的最长回文字符串。若字符串s为回文串，则输出Y，否则输出N。输出共1行，包含一个整数，表示答案。输入仅一行包含一个字符串s。
idea leetcode-edito乱码
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值