从零开始的刷LeetCode生活 第47期 501-515

最新推荐文章于 2023-09-18 03:56:34 发布
最新推荐文章于 2023-09-18 03:56:34 发布
阅读量88 收藏
点赞数
分类专栏： LeetCode刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42549254/article/details/104605604
版权

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> res;
    vector<int> findMode(TreeNode* root) {
        if(!root) return res;
        TreeNode* pre = NULL; //前驱节点
        int curTimes = 1, maxTimes = 0;
        inOrder(root, pre, curTimes, maxTimes);
        return res;
    }

    void inOrder(TreeNode* root, TreeNode*&pre, int &curTimes, int &maxTimes) //pre要改变加&
    {
        if(!root) return;
        inOrder(root->left, pre, curTimes, maxTimes);
        if(pre)
            curTimes = (root->val == pre->val) ? curTimes + 1 : 1;
        if(curTimes == maxTimes)
            res.push_back(root->val);
        else if(curTimes > maxTimes)
        {
            res.clear();
            res.push_back(root->val);
            maxTimes = curTimes;
        }
        pre = root;
        inOrder(root->right, pre, curTimes, maxTimes);
    }
};

在这里插入图片描述

class Solution {
public:
    int findMaximizedCapital(int k, int W, vector<int>& Profits, vector<int>& Capital) {
        int n = Profits.size();
        vector<pair<int, int>> tmp(n);
        for(int i = 0; i < n; i ++)
            tmp[i] = make_pair(Capital[i], Profits[i]);

        //将项目按照资本从小到大排序。
        sort(tmp.begin(), tmp.end());
        priority_queue<int>heap; //存储最大利润的大根堆
        int i = 0;
        while(k --)
        {
            while(i < n && W >= tmp[i].first)
            {
                heap.push(tmp[i].second);
                i++;
            }
            if(!heap.empty())
            {
                W += heap.top();
                heap.pop();
            }
        }
        return W;
    }
};

在这里插入图片描述

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int>res(nums.size(), -1);
        vector<int>tmp(2 * nums.size(), -1);
        for(int i = 0; i < nums.size(); i ++)
        {
            tmp[i] = nums[i];
            tmp[nums.size() + i] = nums[i];
        }

        for(int i = 0; i < nums.size(); i ++)
            for(int j = i; j < tmp.size(); j ++)
                if(tmp[j] > nums[i])
                {
                    res[i] = tmp[j];
                    break;
                }                
        return res;
    }
};

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int> res(n, -1);
        stack<int> stk;
        for(int i = 0; i < 2 * n; i ++)
        {
            while(!stk.empty() && nums[i % n] > nums[stk.top()])
                res[stk.top()] = nums[i % n], stk.pop();
            if(i < n) stk.push(i);               
        }
        return res;
    }
};

在这里插入图片描述

class Solution {
public:
    string convertToBase7(int num) {
        if(num < 0) return string{'-'} + convertToBase7(-1 * num);
        if(num < 7) return to_string(num);
        return convertToBase7(num / 7) + to_string(num % 7);
    }
};

class Solution {
public:
    string convertToBase7(int num) {
        string res;
        if(num == 0) return "0";
        bool is_neg = false;
        if(num < 0) is_neg = true, num *= -1;
        while(num)
        {
            res += to_string(num % 7);
            num /= 7;
        }
        if(is_neg) res += '-';
        reverse(res.begin(), res.end());
        return res;
    }
};

在这里插入图片描述

class Solution {
public:
    vector<string> findRelativeRanks(vector<int>& nums) {
        int n = nums.size();
        vector<string>res(n);       
        map<int, int>m; //map自动排序       
        for(int i = 0; i < n; i ++)
            m[nums[i]] = i;
        for(auto x : m)
        {
            if(n == 1) res[x.second] = "Gold Medal";
            else if(n == 2) res[x.second] = "Silver Medal";
            else if(n == 3) res[x.second] = "Bronze Medal";
            else res[x.second] = to_string(n);
            n --;
        }
        return res;
    }
};

在这里插入图片描述

class Solution {
public:
    bool checkPerfectNumber(int num) {
        if(num == 1) return false;
        int sum = 0;
        for(int i = 2; i * i < num; i ++)
            sum += num % i == 0 ? i + num / i : 0; //2 18 3 12 4 9 
        return sum + 1 == num;
    }
};

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> findFrequentTreeSum(TreeNode* root) {
        int max_count = 0;
        unordered_map<int, int>m;
        dfs(root, m, max_count);
        vector<int>res;
        for(auto &p : m)
        {
            if(p.second == max_count)
                res.push_back(p.first);
        }
        return res;
    }
    int dfs(TreeNode* root, unordered_map<int, int>&m, int &max_count)
    {
        if(!root) return 0;
        int l = dfs(root->left, m, max_count);
        int r = dfs(root->right, m, max_count);
        int s = l + r + root->val;
        max_count = max(max_count, ++m[s]);
        return s;
    }
};

在这里插入图片描述

class Solution {
public:
    int fib(int N) {
        if(N == 0) return 0;
        if(N == 1) return 1;
        return fib(N - 1) + fib(N - 2);
    }
};

class Solution {
public:
    int fib(int N) {
    vector<int> dp(N + 3, 0);
    // base case
    dp[1] = dp[2] = 1;  //这里有bug 上面的初始化要大一点，不然数组越界
    for (int i = 3; i <= N; i++)
        dp[i] = dp[i - 1] + dp[i - 2];
    return dp[N];
    }
};

class Solution {
public:
    int fib(int N) {
        if(N == 0) return 0;
        if(N == 1 || N == 2) return 1;
        int prev = 1, curv = 1;
        for(int i = 3; i <= N; i ++)
        {
            int sum = prev + curv;
            prev = curv;
            curv = sum;
        }
        return curv;
    }
};

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        if(!root) return -1;
        queue<TreeNode*>q;
        q.push(root);
        TreeNode*p;
        while(!q.empty())
        {
            p = q.front(), q.pop();
            if(p->right) q.push(p->right);
            if(p->left) q.push(p->left);
        }
        return p->val;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int res;
    int max = INT_MIN;
    int findBottomLeftValue(TreeNode* root) {
        dfs(root, 0);
        return res;
    }

    void dfs(TreeNode* root, int depth)
    {
        if(root)
        {
            if(!root->left && !root->right) //叶子节点
            {
                if(depth > max)
                {
                    max = depth;
                    res = root->val;
                }
            }
            dfs(root->left, depth + 1);
            dfs(root->right, depth + 1);
        }
    }
};

在这里插入图片描述

class Solution {
public:
    int findRotateSteps(string ring, string key) {
        int m = ring.size(), n = key.size(), cost = 0, res = INT_MAX;
        int dp[n][m];
        memset(dp, 0, n * m * sizeof(int)); //初始化
        for(int i = 0; i < m; i ++)
            if(ring[i] == key[0])
                dp[0][i] = min(i + 1, m - i + 1);
        for(int i = 1; i < n; i ++)
            for(int j = 0; j < m; j ++)
            {
                dp[i][j] = INT_MAX;
                if(key[i] == ring[j])
                {
                    for(int k = 0; k < m; k ++) //上一次十二点的位置
                    {
                        if(key[i - 1] == ring[k])
                        {
                            cost = dp[i - 1][k] + min((j - k + m) % m, (k - j + m) % m) + 1;
                            dp[i][j] = min(dp[i][j], cost);
                        }
                    }
                }
            }    
        for(int i = 0; i < m; i ++)
            if(ring[i] == key[n - 1])
                res = min(res, dp[n - 1][i]);
        return res;
    }
};

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int>res;
    vector<int> largestValues(TreeNode* root) {
        if(!root) return res;
        dfs(root, 0);
        return res;
    }

    void dfs(TreeNode* root, int level)
    {
        if(!root) return;
        if(res.size() == level) res.push_back(root->val);
        res[level] = max(res[level], root->val);
        dfs(root->left, level + 1);
        dfs(root->right, level + 1);
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        queue<TreeNode*>q;
        q.push(root);
        while(!q.empty())
        {
            int levelSize = q.size();
            int levelMax = INT_MIN; //当前行的最小值
            for(int i = 0; i < levelSize; i ++)
            {
                TreeNode* curNode = q.front();
                q.pop();
                levelMax = max(levelMax, curNode->val);
                if(curNode->left) q.push(curNode->left);
                if(curNode->right) q.push(curNode->right);
            }
            res.push_back(levelMax);
        }
        return res;
    }
};
WMXNLFD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从零开始的leetcode刷题 （C++，Python，Java）
Y_icey的博客
07-25 264
本文 不会详细描述解题思路，纯粹作为自己的刷题记录贴。 具体题目内容就不在这里贴出，只放出自己的解题答案： 第一题 //执行时间100ms，使用内存9.9m //C++暴力算法 class Solution { public: vector<int> twoSum(vector<int>& nums, int target) { vector<int> result; for (int i = 0; i < num
从零开始刷leetcode的经验总结，主要是Top Interview Questions
weixin_41699413的博客
09-13 4893
从零开始刷leetcode的经验总结
玩转力扣 - LeetCode进度倒计数表
极客学长 | 极客学长Bravo
08-06 1008
玩转力扣 - LeetCode进度倒计数表 快速搜索题号、题解、代码、标签等，请善用 Ctrl+F（或者 Command+F）。 ps: 前600题中有120个加锁题(120????/前600) 题号 题目 有无锁 标签 难度 代码 AC状态 10 正则表达式匹配 递归, 字符串, 动态规划 困难 32 最长有效括号 栈, 字符串, 动态规划 困难 37 解数独 数组, 回溯, 矩阵 困难 40 组合总和 II 数组, 回溯 中等 42 接
LeetCode刷题笔记（Java）---第41-60题
gongsenlin341的博客
03-17 666
目录 文章目录目录其他篇章1-18题19-40题41. 缺失的第一个正数 其他篇章 1-18题 19-40题 41. 缺失的第一个正数 给定一个未排序的整数数组，找出其中没有出现的最小的正整数。 示例 1: 示例 2: 示例 3: 说明: 你的算法的时间复杂度应为O(n)，并且只能使用常数级别的空间。 解答 public int firstMissingPositive(int[...
LeetCode（编程基础0到1 --篇）c++
weixin_75205835的博客
08-13 830
直接判断如果是负数就直接false。
leetcode(十)---双指针
qq_45040551的博客
09-07 596
文章目录前言一、盛水最多的容器二、三数之和三、 删除有序数组中的重复项四、 实现strStr（）五、颜色分类总结 前言 双指针相关题解 一、盛水最多的容器 给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 说明：你不能倾斜容器。 class Solution { public int maxAre
java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新
殷志鹏的博客
04-25 714
本文相当于目录方便快速检索内容，没有实际内容，只做索引 源码(码云)：https://gitee.com/yin_zhipeng/data_structures_and_algorithms_in_java.git 文章目录一、堆栈（Stack） 一、堆栈（Stack）
从零开始的力扣刷题记录-第七十二天
qq_24494293的博客
06-29 488
今天比较顺利，两道中等题都不难，动态规划是昨天题的加强版，但是动态规划这种题知道状态怎么转移就很好做了。
从零开始的力扣刷题记录-第二十七天
qq_24494293的博客
05-15 312
位运算还是不太会，反转K次那个题代码写的比较啰嗦。
Leetcode 01-算法入门与数组-③数组排序
最新发布
qq_34903176的博客
09-18 293
这个过程就像水底的气泡一样从底部向上「冒泡」到水面，这也是冒泡排序法名字的由来。接下来，我们使用「冒泡」的方式来模拟一下这个过程。假设数组的元素个数为 nnn 个，则冒泡排序的算法步骤如下：我们以 [5,2,3,6,1,4][5, 2, 3, 6, 1, 4][5,2,3,6,1,4] 为例，演示一下冒泡排序的整个过程。 4. 冒泡排序算法分析 最佳时间复杂度：O(n)O(n)O(n)。最好的情况下（初始时序列已经是升序排列），只需经过 111 趟排序，总共经过
leetcode - 必背基础题（JS版）
seaalan的博客
11-22 1226
一、leetcode - 字符串 (JS) 二、leetcode - 二进制、数学类 (JS) 三、leetcode - 数组（JS） 四、leetcode - 二分查找（JS） 五、leetcode - 快慢指针（JS） 六、leetcode - 滑动窗口（JS） 七、leetcode - 矩阵（JS） 八、leetcode - 栈和队列（JS） 九、leetcode - 链表（JS） 十、leetcode - 二叉树（JS） 十一、leetcode - 并查集（JS） 十二、leetcode - 回溯（
leetcode
qq_22081299的博客
07-08 596
数组&字符串 9 回文数 26 从排序数组中删除重复项 27 移除元素 #80 从排序数组中删除重复项II #旋转数组 存在重复元素 136 只出现一次的数字 位运算 137 只出现一次的数字II 260 只出现一次的数字III 多个出现一次 两个数组的交集 II 加一 移动零 有效的数独 #旋转图像 反转字符串 #反转整数 #字符串中的第一个唯一字符 有效的字母异位词 验证回文字符串 字符串转整数 (atoi) 实现strStr() 数数并说 #最长公共前缀 #1 两数
LeetCode-SQL（八）
Sdhrs_nn的博客
03-17 1210
sql题练习
Facebook面试题
WMXNLFD的博客
06-13 877
LeetCode 125. Valid Palindrome 给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。 说明：本题中，我们将空字符串定义为有效的回文串。 示例 1: 输入: “A man, a plan, a canal: Panama” 输出: true 示例 2: 输入: “race a car” 输出: false class Solution { p...
模拟算法专题
WMXNLFD的博客
06-09 639
LeetCode 263. Ugly Number 编写一个程序判断给定的数是否为丑数。 丑数就是只包含质因数 2, 3, 5 的正整数。 示例 1: 输入: 6 输出: true 解释: 6 = 2 × 3 示例 2: 输入: 8 输出: true 解释: 8 = 2 × 2 × 2 示例 3: 输入: 14 输出: false 解释: 14 不是丑数，因为它包含了另外一个质因数 7。 说明： ...
从零开始的刷LeetCode生活 第17期 171-180
WMXNLFD的博客
01-17 478
class Solution { public: int titleToNumber(string s) { int num = 0; for(int i = 0; i < s.size(); i ++) { num = num * 26 + (s[i] - 'A' + 1); } ...
LeetCode(六)二分与单调队列_栈专题
WMXNLFD的博客
05-30 463
LeetCode 69. Sqrt(x) 实现 int sqrt(int x) 函数。 计算并返回 x 的平方根，其中 x 是非负整数。 由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。 示例 1: 输入: 4 输出: 2 示例 2: 输入: 8 输出: 2 说明: 8 的平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。 class Solution { publi...
LeetCode(五)字符串处理专题
WMXNLFD的博客
05-29 400
LeetCode 38. Count and Say 报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下： 1. 1 2. 11 3. 21 4. 1211 5. 111221 1 被读作 “one 1” (“一个一”) , 即 11。 11 被读作 “two 1s” (“两个一”）, 即 21。 21 被读作 “one ...
csdn 刷leetcode不知道从哪里刷起?来看看
09-16
如果你是刚刚开始刷LeetCode，建议你先从简单题开始做起，逐渐熟悉题目的要求和解法。每做完一道题，你可以参考其他人的解答和讨论，学习他们的思路和方法，然后尝试自己写出更优秀的解答。 刷LeetCode是一个长期的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值