pppppppyl-CSDN博客

原创 652. 寻找重复的子树

题目链接：leetcode.是昨天贝壳笔试的原题耶，，，思路是深度优先遍历序列化每一个二叉树，计算当前节点的序列，并与已经遍历过的进行比较，若第二次出现则存储该节点（后面再重复出现已不需要存储啦），，序列化的时候每个节点之间保存一个','，防止出现11 1和1 11被判断为相同/*执行用时：40 ms, 在所有 C++ 提交中击败了72.52%的用户内存消耗：47.8 MB, 在所有 C++ 提交中击败了55.38%的用户*//** * Definition for a binary tree

2021-08-14 14:19:08 81

原创 139. 单词拆分

题目链接：leetcode.想法很天真，哈希表存储某字母开头的所有word，回溯搜索是否能被拆分成功，然后超时/*35 / 45 个通过测试用例状态：超出时间限制"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab"["a","aa","aaa",

2021-08-14 11:41:14 103

原创 233. 数字 1 的个数

题目链接：leetcode.这道题感觉也是做过的，，可是太菜了就忘记了○|￣|_总结规律来说就是对于第k位每10k+1个数就会有10k个1（比如，百位即k=2，[0-999]中百位为1的就有100个数）对于12345而言，一共有12个1000，所以百位为1的个数就是12100，但还剩下345不足1000，里面依然有百位为1的情况，即[100-199]，所以百位为1共有12100 + 100个以此类推，对于第k位，除了有（n/10k+1）*10k个1之外，还要分析t=(n%10k+1)的情况，此处能贡

2021-08-13 17:42:34 117

原创 516. 最长回文子序列

题目链接：leetcode.我是????，这题我竟然想着对每个可能的子序列用dp求回文串的长度，脑子坏掉了吧。。。dp[i][j]表示从i到j的子序列中最长回文串的长度，转移方程在s[i]==s[j]时dp[i][j] = dp[i+1][j-1] + 2，否则呢，s[i]和s[j]不能同时作为子序列的端点，因为没啥贡献，dp[i][j] = max(dp[i+1][j], dp[i][j-1])。注意i、j遍历过程中的顺序/*执行用时：96 ms, 在所有 C++ 提交中击败了78.50%的用户

2021-08-12 16:49:02 71

原创 45. 跳跃游戏 II

题目链接：leetcode.这道题是跳跃游戏的加强版用双循环可以找到答案但时间复杂度是O(n^2)/*执行用时：348 ms, 在所有 C++ 提交中击败了13.45%的用户内存消耗：16.6 MB, 在所有 C++ 提交中击败了5.24%的用户*/class Solution {public: int jump(vector<int>& nums) { int N = nums.size(); vector<int>

2021-08-10 14:48:51 60

原创 313. 超级丑数

题目链接：leetcode.这道题其实就是之前那个[2,3,5]丑数的加强版，自己想了半天没搞明白动态规划怎么写/*错的*/class Solution {public: int nthSuperUglyNumber(int n, vector<int>& primes) { vector<int> ans(1, 1); ans.push_back(primes[0]); int i = 1, j = 1;

2021-08-10 10:40:03 40

原创 457. 环形数组是否存在循环

题目链接：leetcode.因为每个位置都有出度为1，所以数组必有环！有环可以考虑快慢指针，若相遇则说明有环；但本题的目的要找方向一致的环，所以需要判断更新快慢指针过程中的方向是否一致从前到后遍历，将因方向不一致或自循环而跳出的遍历过的值置为0，以此防止重复遍历/*执行用时：4 ms, 在所有 C++ 提交中击败了57.77%的用户内存消耗：7 MB, 在所有 C++ 提交中击败了98.83%的用户*/class Solution {public: bool circularArr

2021-08-07 11:21:03 52

原创 1091. 二进制矩阵中的最短路径

题目链接：leetcode.试图用回溯，超时/*43 / 88 个通过测试用例*/class Solution { vector<vector<int>> dic = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}}; void dfs(vector<vector<int>>& grid, vector<vector<in

2021-08-03 22:44:22 95

原创 797. 所有可能的路径

题目链接：leetcode.图里面的，算是求两个节点之间的路径吧，用深度优先和回溯/*执行用时：8 ms, 在所有 C++ 提交中击败了97.31%的用户内存消耗：11.5 MB, 在所有 C++ 提交中击败了75.64%的用户*/class Solution { vector<vector<int>> ans; vector<int> tmp; void dfs(vector<vector<int>>&amp

2021-08-03 21:45:00 56

原创剑指 Offer 11. 旋转数组的最小数字

题目链接：leetcode.二分法搞了半天没整明白，用暴力找/*执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户内存消耗：11.9 MB, 在所有 C++ 提交中击败了18.10%的用户*/class Solution {public: int minArray(vector<int>& numbers) { int N = numbers.size(); for(int i = 0;i < N - 1;+

2021-07-29 17:24:25 39

原创 438. 找到字符串中所有字母异位词

题目链接：leetcode.依然是滑动窗口，窗口大小是固定的，每次移去最左边并加上最右边，用diff记录当前窗口中s的cnt与p的cnt之间的不同，当diff为0时说明找到了思路与567. 字符串的排列有些类似，就是注意最后是再比较以下以s[n-1]为结尾的窗口是不是符合条件就好啦（当然也可以不这样写/*执行用时：8 ms, 在所有 C++ 提交中击败了97.09%的用户内存消耗：8.5 MB, 在所有 C++ 提交中击败了62.63%的用户*/class Solution {public:

2021-07-29 09:53:24 37

原创 713. 乘积小于K的子数组

题目链接：leetcode.确定右边界nums[j]后，查找满足sum小于k的最小的nums[i]，此时i到j之间以nums[j]为右边界的子数组共有j-i+1个，更新ans，j右移。k = 0的样例，使得每个j都不存在i，所以while(i <= j && sum >= k)/*执行用时：80 ms, 在所有 C++ 提交中击败了66.35%的用户内存消耗：59.7 MB, 在所有 C++ 提交中击败了91.24%的用户*/class Solution {p

2021-07-28 22:40:00 39

原创剑指 Offer 04. 二维数组中的查找

题目链接：leetcode.以为是每行都大于上一行的二分法了，实际上可以用O(N + M)的时间复杂度，从左下角开始查找，大于target就上移，小于target就右移。/*执行用时：20 ms, 在所有 C++ 提交中击败了95.07%的用户内存消耗：12.6 MB, 在所有 C++ 提交中击败了74.92%的用户*/class Solution {public: bool findNumberIn2DArray(vector<vector<int>>&amp

2021-07-28 20:34:36 45

原创 844. 比较含退格的字符串

题目链接：leetcode.不知道咋了今天，简单题都搞不明白用栈解决很简单，双指针的话可以达到O(1)的空间复杂度，从后往前指针指向需要比较的位置，如果i，j越界，则必须两个同时都结束了比较，否则返回false；如果没越界，则要两者相同，才能继续下一次的循环/*执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户内存消耗：6.2 MB, 在所有 C++ 提交中击败了43.58%的用户*/class Solution {public: bool backspaceCo

2021-07-27 20:34:23 44

原创 671. 二叉树中第二小的节点

题目链接：leetcode.遍历整棵二叉树，如果碰到比root->val值大的数便记录为ans，如果遍历结束都没找到，则返回-1，所以ans设初值为-1广度优先遍历，如果碰到比当前记录的ans值还要大（或等于）的节点，说明其子树都比ans大（或等于），则不必再向下遍历遇到比ans小但大于root->val的值，则更新ans/** * Definition for a binary tree node. * struct TreeNode { * int val; *

2021-07-27 11:14:09 42

原创 1713. 得到子序列的最少操作次数

题目链接：leetcode.寻思了半天的dp，超时/*73 / 82 个通过测试用例超出时间限制*/ class Solution {public: int minOperations(vector<int>& target, vector<int>& arr) { int M = target.size(), N = arr.size(); unordered_map<int, vector<int&

2021-07-26 22:28:45 52

原创 33. 搜索旋转排序数组

题目链接：leetcode.思路：即使旋转后，也必定有一部分是有序的。使用二分法，若左半边有序（nums[mid] >= nums[0]），则判断target在不在有序的这半边，继续搜索；右半边有序同理。/*执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户内存消耗：10.8 MB, 在所有 C++ 提交中击败了62.12%的用户*/class Solution {public: int search(vector<int>& nums,

2021-07-24 12:35:54 34

原创 116. 填充每个节点的下一个右侧节点指针

题目链接：leetcode.层次遍历/*// Definition for a Node.class Node {public: int val; Node* left; Node* right; Node* next; Node() : val(0), left(NULL), right(NULL), next(NULL) {} Node(int _val) : val(_val), left(NULL), right(NULL), next(

2021-07-21 17:10:58 35

原创 981. 基于时间的键值存储

题目链接：leetcode./*44 / 46 个通过测试用例超出时间限制*/class TimeMap { unordered_map<string, unordered_map<string, vector<int>>> M; public: /** Initialize your data structure here. */ TimeMap() { } void set(string key, string

2021-07-10 10:23:52 48

原创 494. 目标和

题目链接：leetcode.回溯/*执行用时：1660 ms, 在所有 C++ 提交中击败了9.53%的用户内存消耗：8.6 MB, 在所有 C++ 提交中击败了98.33%的用户*/ class Solution { int ans; void dfs(const vector<int>& nums, int index, int sum, int target) { if(index >= nums.size()) { i

2021-06-07 21:11:44 38

原创 474. 一和零

题目链接：leetcode.竟然是背包问题呢dp[i][j][k]表示前i个字符串中，j个0、k个1能包含的子集数量最终所求即为dp[L][m][n]，L为strs的长度/*执行用时：732 ms, 在所有 C++ 提交中击败了6.06%的用户内存消耗：100.7 MB, 在所有 C++ 提交中击败了5.03%的用户*/class Solution {public: int findMaxForm(vector<string>& strs, int m, int

2021-06-06 22:04:06 57

原创 477. 汉明距离总和

题目链接：leetcode./*36 / 46 个通过测试用例超出时间限制*/class Solution { int Hamming(int num1, int num2) { int tmp = num1 ^ num2; int ans = 0; while(tmp) { ans += (tmp & 1); tmp = tmp >> 1;

2021-05-28 09:47:41 45

原创 1190. 反转每对括号间的子串

题目链接：leetcode./*执行用时：4 ms, 在所有 C++ 提交中击败了42.13%的用户内存消耗：6.4 MB, 在所有 C++ 提交中击败了41.57%的用户*/class Solution {public: string reverseParentheses(string s) { stack<pair<char, int>> stk; stack<int> index; int N = s.size(); for

2021-05-26 22:24:22 44

原创 1787. 使所有区间的异或结果为零

题目链接：leetcode.我是实在没想出来，怎么个动态规划法，我是笨比总结规律最终得到的nums[i] == nums[i + k]，是一个周期循环的数组我们将他们分成k个组，则每个组内的数字都是相等的（最后一组的大小可能会小一点）每个组的数字分别为nums[0],nums[1],...,nums[k-1]dp[i][j]表示前i组异或值为j时（也就是nums[0]^nums[1]^...^nums[i] = j），需要的最小变换次数当第i组的数字nums[i]要变为x时，dp[i][j]

2021-05-25 17:51:26 65

原创 128. 最长连续序列

题目链接：leetcode.排序注意样例[1,2,0,1]/*执行用时：8 ms, 在所有 C++ 提交中击败了93.14%的用户内存消耗：10.5 MB, 在所有 C++ 提交中击败了50.39%的用户 */class Solution {public: int longestConsecutive(vector<int>& nums) { if(nums.empty()) return 0; int N = n

2021-05-24 10:40:07 40

原创 664. 奇怪的打印机

题目链接：leetcode.emmm dp[i][j]表示从i到j的最小操作数当s[i] == s[j]时，dp[i][j] = dp[i][j-1]，因为在打印s[i]的时候把s[j]可以一起打了，不影响中间的s[i+1 : j-1]当s[i] != s[j]时，左右两边要分开打印，分界线为s[k]，dp[i][j] = min(dp[i][k-1] + dp[k][j])，i<k<=j转移方程初始条件为dp[i][i]=1，i从大往小变(k > i)，j从小往大变(k <

2021-05-24 09:32:00 59

原创 1707. 与数组中元素的最大异或值

题目链接：leetcode.暴力果然是无法通过的/*55 / 67 个通过测试用例*/class Solution {public: vector<int> maximizeXor(vector<int>& nums, vector<vector<int>>& queries) { sort(nums.begin(), nums.end()); int N = queries.size();

2021-05-23 13:39:03 32

原创 208. 实现 Trie (前缀树)

题目链接：leetcode./*执行用时：1232 ms, 在所有 C++ 提交中击败了5.02%的用户内存消耗：62.4 MB, 在所有 C++ 提交中击败了8.15%的用户*/class Trie { unordered_map<string, int> tree; bool isPre(string a, string b) { if(a == b) return true; if(a.size() <= b.size()) return fa

2021-05-23 10:16:00 44

原创 1035. 不相交的线

题目链接：leetcode.好家伙，我以为又是图的题呢，没想到这次是动态规划找到的不相交的节点肯定满足i1 < i2则j1 < j2所以最终找到的k个节点之间肯定i1 < i2 < ... < ik, j1 < j2 < ... < jk问题转化为求两个数组之间的最长公共子序列（虽然我一时也忘了咋算dp[i][j]表示前i个和前j个的最长公共子序列的长度/*执行用时：16 ms, 在所有 C++ 提交中击败了78.81%的用户内存消耗：12.8

2021-05-21 09:07:29 56

原创 114. 二叉树展开为链表

题目链接：leetcode.递归/*执行用时：8 ms, 在所有 C++ 提交中击败了65.91%的用户内存消耗：12.4 MB, 在所有 C++ 提交中击败了44.38%的用户*/class Solution {public: void flatten(TreeNode* root) { if(root == nullptr) return; flatten(root -> left); flatten(root -> ri

2021-05-20 10:52:59 31

原创 692. 前K个高频单词

题目链接：leetcode./*执行用时：12 ms, 在所有 C++ 提交中击败了86.28%的用户内存消耗：11.2 MB, 在所有 C++ 提交中击败了20.92%的用户*/class Solution {public: vector<string> topKFrequent(vector<string>& words, int k) { unordered_map<string, int> map; for(auto

2021-05-20 09:34:05 54

原创 1442. 形成两个异或相等数组的三元组数目

题目链接：leetcode.暴力三重循环/*执行用时：176 ms, 在所有 C++ 提交中击败了13.02%的用户内存消耗：7.5 MB, 在所有 C++ 提交中击败了30.23%的用户*/class Solution {public: int countTriplets(vector<int>& arr) { if(arr.empty()) return 0; int N = arr.size(); vector<

2021-05-18 14:08:45 30

原创 96. 不同的二叉搜索树

题目链接：leetcode.我应该做过，，提示说是动态规划emmm1~n的数字，如果用i作为根节点，那么左子树就是1~i-1，右子树就是i+1~nG(n)表示n个数字有几种二叉搜索树的排列对于i作为根节点而言，排列数 = G(i-1) * G(n - i)G(n)就是枚举i得到的排列数之和/*执行用时：4 ms, 在所有 C++ 提交中击败了15.43%的用户内存消耗：6 MB, 在所有 C++ 提交中击败了8.69%的用户*/class Solution {public: i

2021-05-16 10:20:47 176

原创 421. 数组中两个数的最大异或值

题目链接：leetcode.暴力34 / 39 个通过测试用例class Solution {public: int findMaximumXOR(vector<int>& nums) { int N = nums.size(); int ans = INT_MIN; for(int i = 0;i < N;++i) { for(int j = i;j < N;++j)

2021-05-16 09:17:04 60

原创 12. 整数转罗马数字

题目链接：leetcode./*执行用时：12 ms, 在所有 C++ 提交中击败了43.10%的用户内存消耗：6.3 MB, 在所有 C++ 提交中击败了32.94%的用户*/class Solution {public: string intToRoman(int num) { vector<int> key = {1000, 500, 100, 50, 10, 5, 1}; vector<char> value = {'M',

2021-05-14 11:32:50 36

原创 94. 二叉树的中序遍历

题目链接：leetcode.递归/** * 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), rig

2021-05-13 16:12:06 51

原创 1269. 停在原地的方案数

题目链接：leetcode.还以为是回溯，看了提示说是动态规划，那我就瞎写写吧28 / 31 个通过测试用例超时class Solution {public: int numWays(int steps, int arrLen) { vector<vector<int>> dp(steps, vector<int>(arrLen, 0)); dp[0][0] = 1; dp[0][1] = 1;

2021-05-13 09:29:43 34

原创 79. 单词搜索

题目链接：leetcode.从每一个位置开始，搜索是否能匹配/*执行用时：452 ms, 在所有 C++ 提交中击败了28.00%的用户内存消耗：7.1 MB, 在所有 C++ 提交中击败了71.64%的用户*/class Solution { vector<vector<int>> visit; bool dfs(vector<vector<char>>& board, int i, int j, string word, int

2021-05-12 10:36:14 33

原创 1734. 解码异或后的排列

题目链接：leetcode.我还是太菜了，不知道怎么捣鼓出perm[0]啊。。还没看清楚题，题目都说了perm是前n个正整数的排列所以从1异或到n就是整个perm的异或值嘛encoded保证是奇数个，所以encoded[1] ^ encoded[3] ^ ...就只差了个perm[0]/*执行用时：168 ms, 在所有 C++ 提交中击败了45.82%的用户内存消耗：95.6 MB, 在所有 C++ 提交中击败了94.82%的用户*/class Solution {public:

2021-05-11 09:06:28 55

原创 72. 编辑距离

题目链接：leetcode.word1变成word2的每一步所能进行的操作有word1插入一个字符word2插入一个字符（word1删除一个字符）word1修改一个字符使用动态规划dp[i][j]表示word1的前i个字符变成word2的前j个字符使用的最少操作数dp[0][j] = j，dp[i][0] = i三种变化形式word1插入一个字符 = dp[i - 1][j] + 1word2插入一个字符 = dp[i][j - 1] + 1修改字符 = dp[i - 1][j - 1]

2021-05-10 10:00:56 76

空空如也

空空如也