leetcode算法专题训练：十五.细节实现专题

最新推荐文章于 2022-06-02 18:59:52 发布
最新推荐文章于 2022-06-02 18:59:52 发布
阅读量677 收藏
点赞数
分类专栏： Leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Worthy_Wang/article/details/113497462
版权

文章目录

十五.细节实现专题

66.加一

题目描述：给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/plus-one

解题思路：该题从后往前一次遍历即可求得。

时间复杂度：O(N)

空间复杂度：O(1)

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int carry = 1;
        int i = digits.size() - 1;
        while (0 <= i)
        {
            int sum =  digits[i] + carry;
            digits[i] = sum % 10;
            carry = sum / 10;
            --i;
            if (!carry)
                break;
        }
        if (carry)
            digits.insert(digits.begin(), 1);
        return digits;
    }
};
7.整数反转

题目描述:给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2^31, 2^31 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer

解题思路：不断对x%10 再/10，将结果累加，并判断有没有越界。

时间复杂度：O(logX)

空间复杂度：O(1)

class Solution {
public:
    int reverse(int x) {
        long long ans = 0;
        while (x)
        {
            ans = ans * 10 + x%10;
            x /= 10;
            if (ans > INT32_MAX)
                return 0;
            if (ans < INT32_MIN)
                return 0;
        }
        return ans;
    }
};

343. 整数拆分

题目描述：给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/integer-break

解题思路：动态规划, dp[i]代表拆分整数i能够获得的最大乘积

时间复杂度：O(N^2)

空间复杂度：O(N)

class Solution {
public:
    int integerBreak(int n) {
        if (n <= 1)
            return 0;
        vector<int> dp(n + 1, 0);
        dp[1] = 1;
        for (int i = 2; i <= n; ++i)
            for (int j = 1; j < i; ++j)
            {
                int l = std::max(j , dp[j]);
                int r = std::max(i-j, dp[i-j]);
                dp[i] = std::max(dp[i], l * r);
            }
        return dp[n];
    }
};

9.回文数

题目描述:判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
你能不将整数转为字符串来解决这个问题吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-number

解题思路：该题可以用上一题的解法，将数字进行反转再判断是否相同；注意负数不是回文数。

时间复杂度：O(logX)

空间复杂度：O(1)

class Solution {
public:
    bool isPalindrome(int x) {
        if (x < 0)
            return false;
        long res = 0, old = x;
        while (x)
        {
            res = 10 * res + x % 10;
            x /= 10;
        }
        return res==old;
    }
};

56.合并区间

题目描述:给出一个区间的集合，请合并所有重叠的区间。
intervals[i][0] <= intervals[i][1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-intervals

解题思路：直接遍历集合，比较ans.back() 是否与 遍历的元素相连，若相连接的话 修改， 没有连接的话则加入。

时间复杂度：O(NlogN)

空间复杂度：O(1)

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(), intervals.end());
        vector<vector<int>> ans;
        ans.push_back(intervals[0]);
        for (int i = 1; i < intervals.size(); ++i)  
        {
            if (intervals[i][0] > ans.back()[1])
                ans.push_back(intervals[i]);
            else if (intervals[i][1] <= ans.back()[1])
                continue;
            else
                ans.back()[1] = intervals[i][1];
        }
        return ans;
    }
};

57.插入区间

题目描述:给出一个无重叠的 ，按照区间起始端点排序的区间列表。
在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/insert-interval

解题思路：直接适用上一题的方法即可，并且可以不用排序，直接找到位置插入即可。

时间复杂度：O(N)

空间复杂度：O(1)

class Solution {
public:
    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
        int i = 0;
        for (; i < intervals.size(); ++i)
            if (newInterval[0] <= intervals[i][0])
                break;
        intervals.insert(intervals.begin()+i, newInterval);
        vector<vector<int>> ans;
        ans.push_back(intervals[0]);
        for (int i = 1; i < intervals.size(); ++i)  
        {
            if (intervals[i][0] > ans.back()[1])
                ans.push_back(intervals[i]);
            else if (intervals[i][1] <= ans.back()[1])
                continue;
            else
                ans.back()[1] = intervals[i][1];
        }
        return ans;
    }
};

68.文本左右对齐

题目描述:给定一个单词数组和一个长度 maxWidth，重新排版单词，使其成为每行恰好有 maxWidth 个字符，且左右两端对齐的文本。
你应该使用“贪心算法”来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格 ’ ’ 填充，使得每行恰好有 maxWidth 个字符。
要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配，则左侧放置的空格数要多于右侧的空格数。
文本的最后一行应为左对齐，且单词之间不插入额外的空格。
说明:
单词是指由非空格字符组成的字符序列。
每个单词的长度大于 0，小于等于 maxWidth。
输入单词数组 words 至少包含一个单词。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/text-justification

解题思路：

时间复杂度：

空间复杂度：

149.直线上最多的点数

题目描述:给定一个二维平面，平面上有 n 个点，求最多有多少个点在同一条直线上。
示例 1:
输入: [[1,1],[2,2],[3,3]]
输出: 3
解释:
^
|
| o
| o
| o
±------------>
0 1 2 3 4
示例 2:
输入: [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出: 4
解释:
^
|
| o
| o o
| o
| o o
±------------------>
0 1 2 3 4 5 6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/max-points-on-a-line

解题思路：依次遍历各个点，与后面的点进行计算斜率，找出同一个斜率中拥有的最多点数即可。需要注意两点：1.斜率可能出现与x轴或者y轴相平行，所以斜率的形式要用string表示；2.可能会出现重复的点的情况，所以用dup记录重复的点的个数。

时间复杂度：O(N^2)

空间复杂度：O(N)

class Solution {
public:
    int GCD(int a, int b)
    {
        while (b)
        {
            int t = a % b;
            a = b; 
            b = t;
        }
        return a;
    }

    int maxPoints(vector<vector<int>>& points) {
        if (points.empty())
            return 0;
        int n = points.size();
        int ans = 0;
        for (int i = 0; i < n; ++i)
        {
            unordered_map<string, int> hashmap; // <以第i个点为起点的斜率, 直线数>
            int dup = 0;
            int maxHashVal = 0;
            for (int j = i + 1; j < n; ++j)
            {
                int diffx = points[j][0] - points[i][0];
                int diffy = points[j][1] - points[i][1];
                if (diffx == 0 && diffy == 0)
                {
                    dup ++;
                    continue;
                }
                int gcd = GCD(diffx, diffy);
                string key = to_string(diffx / gcd) + "/" + to_string(diffy / gcd);
                hashmap[key] ++;
                maxHashVal = std::max(maxHashVal, hashmap[key]);                   
            }
            ans = std::max(ans, dup + 1 + maxHashVal);
        } 
        return ans;
    }
};

93.复原IP地址

题目描述:给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。
例如：“0.1.2.201” 和 “192.168.1.1” 是 有效的 IP 地址，但是 “0.011.255.245”、“192.168.1.312” j是 无效的 IP 地址。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/restore-ip-addresses

解题思路：DFS法，设置path辅助变量存储分割好的数字，设置start起始位置作为每一次数字的开头，剪枝操作实质上也就是将不符合规定的IP地址值跳过。

时间复杂度：O(N!)

空间复杂度：O(N)

class Solution {
    vector<string> ans;
public:
    void DFS(string& s, int start, vector<string>& path)
    {
        if (start == s.size() && 4 == path.size())
        {
            string res = path[0] + "." + path[1] + "." + path[2] + "." + path[3];
            ans.push_back(std::move(res));
            return;
        }
        if (path.size() > 4)
            return;

        for (int i = start; i < s.size(); ++i)
        {
            string str = s.substr(start, i-start + 1);
            if (stoi(str) > 255)
                break;
            path.push_back(str);
            DFS(s, i+1, path);
            path.pop_back();
            if ("0" == str)
                break;
        }
    }

    vector<string> restoreIpAddresses(string s) {
        vector<string> path;
        DFS(s, 0, path);
        return ans;
    }
};

12.整形转罗马数字

题目描述：罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个整数，将其转为罗马数字。输入确保在 1 到 3999 的范围内。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/integer-to-roman

解题思路：首先使用vector进行整形数字与罗马数字的映射（不用哈希表的原因是无法将数字进行从大到小的遍历），我们注意到 4, 9 这样的数是需要单独设置的，也就是这些需要有单独个性的数，需要添加到哈希表里面去；接下来再从最大的数字（1000）开始求余数，再将罗马数字累加即可得到结果。

时间复杂度：O(N)

空间复杂度：O(1)

class Solution {
public:
    string intToRoman(int num) {
        vector<int> iVec{1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000};
        vector<string> sVec{"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M"};
        string ans;
        for (int i = iVec.size() - 1; i >= 0; --i)
        {
            int cnt = num / iVec[i];
            num %= iVec[i];
            for (int j = 0; j < cnt; ++j)
                ans = ans + sVec[i];
        }
        return ans;
    }
};

13.罗马数字转整形

题目描述：
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/roman-to-integer

解题思路：创建哈希表实现 罗马数字->普通数字，从罗马数字的字符串开始遍历，注意罗马数字可能会是两个连续的字符。

时间复杂度：O(N)

空间复杂度：O(1)

class Solution {
public:
    int romanToInt(string s) {
        unordered_map<string, int> hashmap{{"I", 1}, {"IV", 4}, {"V",5}, {"IX", 9}, {"X", 10},  {"XL", 40}, {"L", 50}, {"XC", 90}, {"C", 100}, {"CD", 400}, {"D", 500}, {"CM", 900}, {"M", 1000}};
        int i = 0;
        int ans = 0;
        while (i < s.size())
        {
            if (hashmap.count(s.substr(i, 2)))
            {
                ans += hashmap[s.substr(i, 2)];
                i += 2;
            }else
            {
                ans += hashmap[s.substr(i, 1)];
                i += 1;
            }
        }
        return ans;
    }
};

17.电话号码的字母组合

题目描述:给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。此题需要看原链接。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number

解题思路：回溯法

时间复杂度：O(K^N) K是数字对应字符串的平均长度

空间复杂度：O(N) N是数字字符串的长度

class Solution {
    vector<string> ans;
    unordered_map<char, string> hashmap{{'2',"abc"}, {'3',"def"},{'4',"ghi"},{'5',"jkl"},{'6',"mno"},{'7',"pqrs"},{'8',"tuv"}, {'9', "wxyz"}};
public:
    void DFS(string& digits, int start, string& path)
    {
        if (path.size() == digits.size())
        {
            ans.push_back(path);
            return;
        }

        string s = hashmap[digits[start]];
        for (int i = 0; i < s.size(); i++)
        {
            path.push_back(s[i]);
            DFS(digits, start+1, path);
            path.pop_back();
        }
    }

    vector<string> letterCombinations(string digits) {
        if (digits.empty())
            return {};
        string path;
        DFS(digits, 0, path);
        return ans;
    }
};

470. 用 Rand7() 实现 Rand10()

题目描述:给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。此题需要看原链接。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/implement-rand10-using-rand7

解题思路：rand7()能等概率生成 1~7；
rand7() - 1 能等概率生成 0 ~ 6；
(rand7() - 1) * 7 能够等概率生成 0, 7, 14, 21, 28, 35, 42;
(rand7() - 1) * 7 + rand7() 能等概率生成 1~49

时间复杂度：O(1) 当然最坏情况下会一直>40也就是O(无穷)

空间复杂度：O(1)

class Solution {
public:
    int rand10() {
        int num;
        do
        {
            num = (rand7() - 1) * 7 + rand7(); // 1~49
        } while (num > 40);
        return num % 10 + 1; //(1~40 -1) % 10 + 1
    }
};

如果是random5 实现 random7 的话：

    int random7()
    {
        int i;
        do
        {
            i = (rand5() - 1) * 5 + rand5();  // i is now uniformly random between 1 and 25
        } while(i > 21);
        // i is now uniformly random between 1 and 21
        return i % 7 + 1;  // result is now uniformly random between 1 and 7
    }

还有一种情景题实现：
30万个员工，工卡是1-30万，抽出10万个员工发奖。
已有一个随机数生成函数rand()能够生成0-65535的整数，写一个公平的抽奖程序，输出这10万个员工的工卡号码
(进阶：30万抽99999个员工)


int rand300000()
{
	int x = 0;
    do
    {
        x= rand() * 65536 + rand() + 1; //(0 ~ 65535) * 65536  + random65536() = (1~ 65536*65536)
    }while(x > 65536*65536/30w * 30w);
    return x % 30w + 1;
}

Worthy_Wang
关注
专栏目录
leetcode分类-leetcode:https://github.com/huxiaoman7/leetcodebook.git
06-30
leetcode 分类 LeetCode-book LeetCode 1~400题总结 + 专题知识点&题型总结 Leetcode知识点详解&题型总结 | | LeetCode题目分类 数组类题目 K-SUM类题目 序号 题目 难度 代码 1 easy python、java、c++ 167 Easy ...
随机函数rand 抽样问题
much efforts, much luck
09-18 2078
一、工行有30万个员工，其工卡号码分别是1~30万，在接下来的某天他们将举行年会，需要抽出10万个员工发奖品。 我们有一个随机数生成函数rand()能够生成0~65535的整数，请写一个公平的抽奖程序，输出这10万个员工的工卡号码。 注：直接在这里写代码，要求使用C++实现完整的代码 ...
Leetcode各种题型题目+思路+代码（共176道题及答案）
热门推荐
muli522的博客
05-16 4万+
文章目录 第一章：Leetcode 每日很多题 1、Leetcode-1047 删除字符串中的所有相邻重复项 2、剑指 Offer 53 - I. 在排序数组中查找数字 I 3、Leetcode704:二分查找 4、 Leetcode 227：基本计算器II 5、leetcode 224：基本计算器(带括号的计算) 6、Leetcode 15：三数之和：排序+双指针 7、剑指 offer 38.字符串的排列 8、Leetcode409：最长回文串 9、Leetcode 331：验证二叉树的前序序列化 10、
腾讯WXG面试题 生成随机数
Elon Zero的博客
04-24 1963
问题描述 工行有30万员工，现在要均匀抽出1万员工发奖品，提供一个16位的随机数生成器函数 rand16() 可供随意调用，请写一个函数 selectLuckyStaffs() 实现这个功能。 如何用rand5()生成rand7() 先看一个数据量不这么大的的类似题目，题目描述如下 给你一个能生成1到5随机数的函数，用它写一个函数生成1到7的随机数。 (即，使用函数rand5()来实现函数rand...
leetcode算法专题训练：五.树专题
Worthy_Wang的博客
01-29 1202
五.树专题 144.二叉树的前序遍历 94.二叉树的中序遍历 145.二叉树的后序遍历 102.二叉树的层序遍历 107.二叉树的层次遍历2 103.二叉树的锯齿形层次遍历 100.相同的树 101.对称二叉树 226. 翻转二叉树 剑指 Offer 26. 树的子结构 110.平衡二叉树 111.二叉树的最小深度 104.二叉树的最大深度 114.二叉树展开为链表 116.充填每个节点的下一个右侧节点指针 117.充填每个节点的下一个右侧节点指针2 105.从前序与中序遍历序列构造二叉树 106.从中.
Leetcode - 广度优先遍历
zhouweihit的专栏
10-28 503
1 2 3 4
leetcode分类-LeetCode:LeetCode.com上的算法解决方案
06-30
《LeetCode: LeetCode.com上的算法解决方案》 LeetCode是一个广受欢迎的在线平台，它提供了大量的编程挑战，旨在提升开发者们的算法技能和问题解决能力。这个压缩包中的内容，"LeetCode分类-LeetCode:LeetCode.com...
leetcode答案-leetcode:http://oj.leetcode.com中所有问题的答案
06-30
这个压缩包文件“leetcode答案-leetcode”包含了在http://oj.leetcode.com上所有问题的解决方案，这是一份宝贵的资源，尤其对于正在学习算法、准备面试或者热衷于提升编程技巧的人。 该压缩包中的“leetcode-master...
LeetCode算法与golang解决方案更新.zip
最新发布
05-25
在编程领域，LeetCode是一个非常受欢迎的在线平台，它提供了大量的算法题目，旨在帮助开发者提升他们的编程技能，尤其是解决问题的能力。Golang，一种由Google开发的静态类型语言，以其简洁的语法、高效的性能以及...
leetcode题库-LeetCode:LeetCode算法：使用Java和kotlin
06-29
LeetCode 是一个在线编程挑战平台，它提供了丰富的算法和数据结构题目，旨在帮助开发者提升编程技能，准备技术面试。这个压缩包"LeetCode-master"很可能包含了一个完整的LeetCode题目的解决方案仓库，支持Java和...
leetcode算法专题训练：六.排序专题
Worthy_Wang的博客
01-29 402
六.排序专题 88.合并两个有序数组 21.合并两个有序链表 23.合并K个升序链表 147.对链表进行插入排序 148.排序链表 75.颜色分类 剑指 Offer 40. 最小的k个数 剑指 Offer 41. 数据流中的中位数 剑指 Offer 45. 把数组排成最小的数 剑指 Offer 51. 数组中的逆序对 六.排序专题 88.合并两个有序数组 题目描述: 给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 .
（每日一练c++）68. 文本左右对齐
weixin_39827856的博客
06-02 449
给定一个单词数组words 和一个长度maxWidth，重新排版单词，使其成为每行恰好有maxWidth个字符，且左右两端对齐的文本。 你应该使用 “贪心算法” 来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格' '填充，使得每行恰好有 maxWidth个字符。 要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配，则左侧放置的空格数要多于右侧的空格数。 文本的最后一行应为左对齐，且单词之间不插入额外的空格。 注意: 单词是指由非空格字符组成...
leetcode算法专题训练：一.数组专题
Worthy_Wang的博客
01-29 1354
一.数组专题 26.删除排序数组中的重复项 80.删除排序数组中的重复项2 剑指 Offer 39. 数组中出现次数超过一半的数字 剑指 Offer 57. 和为s的两个数字 剑指 Offer 57 - II. 和为s的连续正数序列 1.两数之和 15.三数之和 16.最接近的三数之和 18.四数之和 27.移除元素 11.盛最多水的容器 42.接雨水 48.旋转图像 66.加一 70.爬楼梯 73.矩阵置零 134.加油站 135.分发糖果 剑指 Offer 03. 数组中重复的数字 41.缺失的第一.
LeetCode算法题 :打家劫舍rob
Mike的博客
06-10 314
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。 示例 1: 输入: [1,2,3,1] 输出: 4 解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 ...
leetcode精选高频hard题目
Worthy_Wang的博客
02-01 4555
leetcode精选高频hard题目 4.寻找两个正序数组的中位数 60.排列序列 37.解数独 51.N皇后 52.N皇后2 149.直线上最多的点数 42.接雨水 135.分发糖果 41.缺失的第一个正数 25.K个一组翻转链表 65.有效数字 28.实现strStr() 132.分割回文串2 44.通配符匹配 10.正则表达式匹配 97.交错字符串 72.编辑距离 32.最长的有效括号 84.柱状图中最大的矩形 85.最大矩阵 239. 滑动窗口最大值 99.恢复二叉搜索树 124.二叉树中的最大.
leetcode算法专题训练：三.字符串专题
Worthy_Wang的博客
01-29 1331
三.字符串专题 151. 翻转字符串里的单词 剑指 Offer 05. 替换空格 剑指 Offer 58 - II. 左旋转字符串 125.验证回文串 28.实现strStr() 剑指 Offer 20. 表示数值的字符串 65.有效数字 8.字符串转换整数 67.二进制求和 415.字符串相加 43.字符串相乘 12.整形转罗马数字 13.罗马数字转整形 38.外观数列 71.简化路径 58.最后一个单词的长度 三.字符串专题 151. 翻转字符串里的单词 给定一个字符串，逐个翻转字符串中的每.
leetcode算法专题训练：十.DFS专题
Worthy_Wang的博客
01-29 862
十.DFS专题 130.被围绕的区域 131.分割回文串 132.分割回文串2 87.扰乱字符串 剑指 Offer 13. 机器人的运动范围 36.有效的数独 37.解数独 51.N皇后 52.N皇后2 149.直线上最多的点数 93.复原IP地址 39.组合总合 40.组合总合2 22.括号生成 79.单词搜索 十.DFS专题 130.被围绕的区域 题目描述:给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。 找到所有被 ‘X’ 围绕的区域，并将这些区域.
海量数据：TopK算法
Worthy_Wang的博客
02-11 822
找出无序数组中第K大的元素(前K大元素) 方法一:堆排序 堆排序法： 原理：首先建立k个元素的小顶堆，然后遍历数组并且不断调整小顶堆，遍历之后小顶堆堆顶就是第k大元素，整个小顶堆存放的也就是前K大的元素。 时间复杂度:O(klogk + (n-k)logk) = O(nlogk) 空间复杂度:O(k), 当然也可以不开辟空间，也就是O(1) //调整为最小堆 void heapAdjust(ve...
leetcode算法专题训练：十二.动态规划专题
Worthy_Wang的博客
02-01 816
十二.动态规划专题 62.不同路径 63.不同路径2 剑指 Offer 13. 机器人的运动范围 剑指 Offer 47. 礼物的最大价值 64.最小路径和 120.三角形最小路径和 118.杨辉三角 119.杨辉三角2 343. 整数拆分 53.最大子序和 5.最长回文子串 44.通配符匹配 10.正则表达式匹配 97.交错字符串 72.编辑距离 剑指 Offer 46. 把数字翻译成字符串 91.解码方法 115.不同的子序列 139.单词拆分 140.单词拆分2 剑指 Offer 49. 丑数 剑.
LeetCode算法题解PDF：C++版详细逻辑分析
"这是一份关于LeetCode算法题的解答PDF，由C++语言编写，包含详细的算法逻辑分析。作者是戴方勤(soulmachine@gmail.com)，并在GitHub上有开源项目(https://github.com/soulmachine/leetcode)。此资源旨在帮助准备...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值