从零开始的刷LeetCode生活 第40期 414-430

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

在这里插入图片描述

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        set<int> hash;//set里面会自动排序（从小到大）
        for(auto x : nums)
        {
            hash.insert(x);
            if(hash.size() > 3)
                hash.erase(*hash.begin());
        }
        if(hash.size() < 3)
            return *hash.rbegin();
        else
            return *hash.begin();
    }
};

在这里插入图片描述

class Solution {
public:
    string addStrings(string num1, string num2) {
        string res = "";
        int cur = 0, i = num1.size() - 1, j = num2.size() - 1;
        while(~i || ~j || cur != 0)
        {
            if(~i) cur += num1[i--] - '0';
            if(~j) cur += num2[j--] - '0';
            res += to_string(cur % 10);
            cur /= 10; 
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

在这里插入图片描述

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for(auto x : nums) sum += x;
        if(sum % 2 != 0) return false;
        sum /= 2;
        sort(nums.rbegin(), nums.rend());
        if(nums[0] > sum) return false;
        return dfs(nums, 0, 0, sum);
    }

    bool dfs(vector<int>&nums, int index, int now, int sum)
    {
        if(index > nums.size() - 1) return false;
        if(now + nums[index] == sum) return true;
        else if(now + nums[index] > sum) return dfs(nums, index + 1, now, sum);
        else return dfs(nums, index + 1, now + nums[index], sum) || dfs(nums, index + 1, now, sum);
    }
};

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& matrix) {
        vector<vector<int>> res;
        int n = matrix.size();
        if(n < 1) return res;
        int m = matrix[0].size();
        vector<vector<bool>> Pacific(n, vector<bool>(m, false));
        vector<vector<bool>> Atlantic(n, vector<bool>(m, false));        
        for(int i = 0; i < n; i ++) //循环列
        {
            dfs(matrix, i, 0, Pacific, matrix[i][0]); //左右
            dfs(matrix, i, m - 1, Atlantic, matrix[i][m - 1]);
        }        
        for(int i = 0; i < m; i ++)
        {
            dfs(matrix, 0, i, Pacific, matrix[0][i]); //上下    
            dfs(matrix, n - 1, i, Atlantic, matrix[n - 1][i]);
        }        
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < m; j ++)
                if(Pacific[i][j] && Atlantic[i][j])
                    res.push_back({i, j});
        return res;
    }
    //注意取地址符号 修改visit
    void dfs(vector<vector<int>>&m, int x, int y, vector<vector<bool>>&visit, int pre)
    {
        //cout << 1 ;
        if(x < 0 || y < 0 || x >= m.size() || y >= m[0].size() || visit[x][y] || m[x][y] < pre)
            return;        
        visit[x][y] = true;
        dfs(m, x + 1, y, visit, m[x][y]);
        dfs(m, x - 1, y, visit, m[x][y]);
        dfs(m, x, y + 1, visit, m[x][y]);        
        dfs(m, x, y - 1, visit, m[x][y]);    
    }
};

在这里插入图片描述

class Solution {
public:
    int countBattleships(vector<vector<char>>& board) {
        int res = 0;
        for(int i = 0; i < board.size(); i ++)
            for(int j = 0; j < board[0].size(); j ++)
                if(board[i][j] == 'X')
                {
                    if(i > 0 && board[i - 1][j] == 'X' || j > 0 && board[i][j - 1] == 'X')
                        continue;
                    else res ++;
                }
        return res;
    }
};

在这里插入图片描述

class Solution {
public:
    int strongPasswordChecker(string s) {
        bool is_char, is_digit, is_bchar;
        is_char = is_digit = is_bchar = true;
        for(auto &c : s)
        {
            if(isdigit(c))
                is_digit = false;
            else if(islower(c))
                is_char = false;
            else if(isupper(c))
                is_bchar = false;
        }
        int isnum = is_digit + is_char + is_bchar;
        int ins = 0, ins2 = 0, rep = 0;
        for(int i = 2; i < s.size(); i ++)
        {
            if(s[i] == s[i - 1] && s[i - 1] == s[i - 2])
            {
                int len = 3;
                while(i + 1 < s.size() && s[i + 1] == s[i])
                {
                    i ++; len ++;
                }
                if(len % 3 == 0)
                    ins ++;
                else if(len % 3 == 1)
                    ins2 ++;
                rep += len / 3;
            }
        }
        if(s.size() < 6)
            return max(6 - (int)s.size(), isnum);
        else if(s.size() <= 20)
            return max(rep, isnum);
        else{
            int del = s.size() - 20;
            rep -= min(del, ins);
            if(del - ins > 0)
                rep -= min((del - ins) / 2, ins2);
            if(del - ins - 2 * ins2 > 0)
                rep -= (del - ins - 2 * ins2) / 3;
            return del + max(rep, isnum);
        }
    }
};

在这里插入图片描述

class Solution {
public:
    struct Node{
        int son[2];
    };
    vector<Node> nodes;
    int findMaximumXOR(vector<int>& nums) {
        nodes.push_back(Node({0, 0}));//初始化
        for(auto x : nums)
        {
            int p = 0;
            for(int i = 30; ~i; i --)
            {
                int t = x >> i & 1;
                if(!nodes[p].son[t])
                {
                    nodes.push_back(Node({0, 0}));
                    nodes[p].son[t] = nodes.size() - 1;
                }
                p = nodes[p].son[t];
            }
        }
        int res = 0;
        for(auto x : nums)
        {
            int p = 0, m_xor = 0;
            for(int i = 30; ~i; i --)
            {
                int t = x >> i & 1;
                if(nodes[p].son[!t]) //走相反方向
                {
                    p = nodes[p].son[!t];
                    m_xor += 1 << i;
                }
                else
                    p = nodes[p].son[t];
            }
            res = max(res, m_xor);
        }
        return res;
    }
};

在这里插入图片描述

class Solution {
public:
    string originalDigits(string s) {
        int hash[128] = {0};
        for(auto x : s)
            hash[x] ++;
        vector<int>tmp;
        string res = "";
        while(hash['z'] > 0)
        {
            hash['z'] --;hash['e'] --;
            hash['r'] --;hash['o'] --;
            tmp.push_back(0);
        }
        while(hash['w'] > 0)
        {
            hash['t'] --;hash['w'] --;
            hash['o'] --;
            tmp.push_back(2);
        }
        while(hash['u'] > 0)
        {
            hash['f'] --;hash['o'] --;
            hash['u'] --;hash['r'] --;
            tmp.push_back(4);
        }
        while(hash['x'] > 0)
        {
            hash['s'] --;hash['i'] --;
            hash['x'] --;
            tmp.push_back(6);
        }
        while(hash['g'] > 0)
        {
            hash['e'] --;hash['i'] --;
            hash['g'] --;hash['h'] --;
            hash['t'] --;
            tmp.push_back(8);
        }
        while(hash['h'] > 0)
        {
            hash['t'] --;hash['h'] --;
            hash['r'] --;hash['e'] --;
            hash['e'] --;
            tmp.push_back(3);
        }
        while(hash['f'] > 0)
        {
            hash['f'] --;hash['i'] --;
            hash['v'] --;hash['e'] --;
            tmp.push_back(5);
        }
        while(hash['s'] > 0)
        {
            hash['s'] --;hash['e'] --;
            hash['v'] --;hash['e'] --;
            hash['n'] --;
            tmp.push_back(7);
        }
        while(hash['i'] > 0)
        {
            hash['n'] --;hash['i'] --;
            hash['n'] --;hash['e'] --;
            tmp.push_back(9);
        }
        while(hash['o'] > 0)
        {
            hash['o'] --;hash['n'] --;
            hash['e'] --;
            tmp.push_back(1);
        }            
        sort(tmp.begin(), tmp.end());        
        for(auto c : tmp)
            res += to_string(c);        
        return res;
    }
};

在这里插入图片描述

class Solution {
public:
    int characterReplacement(string s, int k) {
        vector<int>hash(26, 0);
        int left = 0, res = 0, maxCnt = 0;
        for(int i = 0; i < s.size(); i ++)
        {
            hash[s[i] - 'A'] ++;
            maxCnt = max(maxCnt, hash[s[i] - 'A']);
            while(i - left + 1 - maxCnt > k)
            {
                hash[s[left]- 'A']--;
                left ++;
            }
            res = max(res, i - left + 1);
        }
        return res;
    }
};

在这里插入图片描述
在这里插入图片描述

/*
// Definition for a QuadTree node.
class Node {
public:
    bool val;
    bool isLeaf;
    Node* topLeft;
    Node* topRight;
    Node* bottomLeft;
    Node* bottomRight;

    Node() {}

    Node(bool _val, bool _isLeaf, Node* _topLeft, Node* _topRight, Node* _bottomLeft, Node* _bottomRight) {
        val = _val;
        isLeaf = _isLeaf;
        topLeft = _topLeft;
        topRight = _topRight;
        bottomLeft = _bottomLeft;
        bottomRight = _bottomRight;
    }
};
*/
class Solution {
public:
    Node* construct(vector<vector<int>>& grid) {
        return dfs(grid, 0, 0, grid.size());
    }
    Node* dfs(vector<vector<int>>&grid, int x, int y, int size)
    {
        if(size <= 0) return 0;
        for(int i = x; i < x + size; i ++)
            for(int j = y; j < y + size; j ++)
            {
                if(grid[i][j] != grid[x][y])
                {
                    return new Node(false, false,
                    dfs(grid, x, y, size / 2),
                    dfs(grid, x, y + size / 2, size / 2),
                    dfs(grid, x + size / 2, y, size / 2),
                    dfs(grid, x + size / 2, y + size / 2, size / 2));
                }
            }
        return new Node(grid[x][y], true, nullptr, nullptr, nullptr, nullptr);
    }
};

在这里插入图片描述

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        if(!root) return res;
        queue<Node*>q;
        q.push(root);
        while(!q.empty())
        {
            vector<int>t;
            for(int i = q.size(); i; i --)
            {
                Node* cur = q.front();
                q.pop();
                t.push_back(cur->val);
                for(Node* it : cur->children)
                    q.push(it);
            }
            res.push_back(t);
        }
        return res;
    }
};

在这里插入图片描述

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* prev;
    Node* next;
    Node* child;
};
*/
class Solution {
public:
    Node* flatten(Node* head) {
        if(!head) return 0;
        Node* cur = head;
        while(cur)
        {
            if(cur->child)
            {
                Node *next = cur->next;
                Node *child = flatten(cur->child);
                cur->next = child;
                child->prev = cur;
                cur->child = NULL;
                if(next)
                {
                    while(cur->next)
                        cur = cur->next;
                    cur->next = next;
                    next->prev = cur;
                }
            }
            cur = cur->next;
        }
        return head;
    }
};
WMXNLFD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode怎么用时间刷_LeetCode刷题专栏第一篇--思维导图&时间安排
weixin_29877175的博客
12-24 346
昨天是元宵节，过完元宵节相当于这个年正式过完了。不知道大家有没有投入继续投入紧张的学习工作中。年前我想开一个Leetcode刷题专栏，于是发了一个投票想了解大家的需求征集意见。投票于2019年2月1日截止，共有204人参加，根据投票结果显示，大多数人希望通过刷LeetCode能够提高代码水平，在工作中和面试中有帮助，然而有一半人没有接触过Leetcode，一半人接触过，但只刷了一点。几乎所有投票的...
从零开始的刷LeetCode生活 第1期 11-20
WMXNLFD的博客
01-01 125
class Solution { public: int maxArea(vector<int>& height) { int res = -1; int i = 0, j = height.size() - 1; while(i < j) { res = max(res, ...
从零开始的刷LeetCode生活 第3期 31-40
WMXNLFD的博客
01-03 66
class Solution { public: void nextPermutation(vector<int>& nums) { for(int i = nums.size() - 1; i; i --) { if(nums[i - 1] < nums[i]) { ...
从零开始的刷LeetCode生活 第44期 466-472
WMXNLFD的博客
02-20 107
class Solution { public: int getMaxRepetitions(string s1, int n1, string s2, int n2) { int idx2 = 0, len2 = s2.size(), cnt = 0; int i = 1; vector<int>v; v.pu...
从零开始刷Leetcode——数组（1.26）
weixin_45325331的博客
05-10 228
文章目录1.两数之和26.删除排序数组中的重复项 马上要去读研了，作为一个转码的ee学生，刷题还是很必要的。从零开始，希望能坚持下去！打算按照类别和难度慢慢刷，一天两三道题左右，争取明年夏季找实习之前能刷完，最差也得把easy和medium过一遍。编程语言为Python，水平有限，要是有更快的解法可以教教我 第一次是数组easy难度的1、26，比较菜，一开始慢点来 1.两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可
从零开始刷Leetcode——数组（268.283.414）
weixin_45325331的博客
05-18 208
文章目录268.缺失数字二级目录三级目录 268.缺失数字 给定一个包含 0, 1, 2, …, n 中 n 个数的序列，找出 0 … n 中没有出现在序列中的那个数。 1.排序 class Solution: def missingNumber(self, nums: List[int]) -> int: length = len(nums) nums.sort() for i in range(length): if
从零开始刷Leetcode——数组（189.217.219）
weixin_45325331的博客
05-15 176
文章目录189.旋转数组217.存在重复元素217.存在重复元素 II 189.旋转数组 给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。 1.定义一个新数组 class Solution: def rotate(self, nums: List[int], k: int) -> None: """ Do not return anything, modify nums in-place instead. """
从零开始刷Leetcode——数组(31.33)
weixin_45325331的博客
06-01 105
文章目录31. 下一个排列33. 搜索旋转排序数组 31. 下一个排列 实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。 如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。 必须原地修改，只允许使用额外常数空间。 例：123变成132；115变成151 1.排序+遍历 class Solution: def nextPermutation(self, nums: List[int]) -> None: """
从零开始刷Leetcode——动态规划（70.198.303）
weixin_45325331的博客
07-21 179
文章目录70. 爬楼梯198. 打家劫舍303. 区域和检索 - 数组不可变 动态规划属于热门问题，在leetcode中主要以medium和hard为主。 70. 爬楼梯 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 注意：给定 n 是一个正整数。 class Solution: def climbStairs(self, n: int) -> int: if n==1: retu
javalruleetcode-Re0-LeetCode:从零开始的LeetCode
06-29
从零开始的LeetCode 主要语言 : C，C++，Java 力扣前 250 名 前400题中重点250道 题号 状态 1 二和 完毕 3 无重复字符的最长子串 完毕 4 两个有序数组的中位数 完毕 5 最长回文子串 完毕 7 反转整数 去做 8 字符串到...
leetcode296-daily-coding-problem:一天的计划让失业者远离
06-30
然后，从这个字符开始，取一个可选的初始加号或减号，后跟尽可能多的数字，并将它们解释为数值。 字符串可以在构成整数的字符之后包含其他字符，这些字符将被忽略并且不会影响此函数的行为。 如果 str 中的第一个非...
leetcode第四题-LeetCodeQs:用python2解决的Leetcode问题
07-01
在本项目"LeetCodeQs:用python2解决的LeetCode问题"中，作者提供了使用Python 2.7语言解答的LeetCode平台上的40道编程题目。LeetCode是一个在线平台，它提供了一系列的编程挑战，旨在帮助程序员提高算法技能和解决...
从零开始的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
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的官方网站，并创建一个账号。然后你可以在主页上看到题目分类和各种练习模式。你可以根据自己的需要选择刷题的方式。 在CSDN上，你可以搜索"LeetCode刷题"或类似的关键词来找到相关的博客和文章。很多程序员会分享自己刷题的经验和解法，你可以从中学习和借鉴。在这些文章中，你可以找到LeetCode的常见题型分类和解题思路。 此外，在CSDN上还有一些专门的LeetCode刷题指导和课程，你可以参考这些资源来系统地学习和刷题。 如果你是刚刚开始刷LeetCode，建议你先从简单题开始做起，逐渐熟悉题目的要求和解法。每做完一道题，你可以参考其他人的解答和讨论，学习他们的思路和方法，然后尝试自己写出更优秀的解答。 刷LeetCode是一个长期的过程，要保持持续的学习和刷题，才能提高自己的编程能力和算法思维。希望你能够坚持下去，享受LeetCode刷题的过程，并不断提高自己！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值