pppppppyl的博客

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

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

题目链接：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)的情况，此处能贡

题目链接：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%的用户

题目链接：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>

题目链接：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;

题目链接：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

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

题目链接：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

题目链接：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

题目链接：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:

题目链接：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

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

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

题目链接：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&

题目链接：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,

题目链接：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(

题目链接：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

题目链接：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

题目链接：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

题目链接：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;

题目链接：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

题目链接：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]

题目链接：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 <

题目链接：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();

题目链接：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

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

题目链接：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

题目链接：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<

题目链接：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)

题目链接：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',

题目链接：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;

题目链接：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:

题目链接：leetcode.提示竟然用回溯，那不也是一种暴力？hhhhhhh我就说嘛，怎么可能这么简单，超时啦，16 / 60 个通过测试用例我不会了，大概需要剪枝吧*求最大值max_element(jobs.begin(), jobs.end())class Solution { int ans; vector<int> tmp; void dfs(const vector<int>& jobs, int k, int index) { if(in

题目链接：leetcode.哈希表，O(n)，O(n)/*执行用时：12 ms, 在所有 C++ 提交中击败了35.80%的用户内存消耗：9.9 MB, 在所有 C++ 提交中击败了5.13%的用户*/class Solution {public: int singleNumber(vector<int>& nums) { unordered_map<int, int> M; for(auto x : nums) { M[x

题目链接：leetcode.我就知道84 / 84 个通过测试用例状态：超出时间限制class Solution {public: int shipWithinDays(vector<int>& weights, int D) { int N = weights.size(); //先找出最小的数（即weights的最大值） int ans = 0; for(auto x : weights) { ans = max(ans,

题目链接：leetcode.回溯会超时8 / 15 个通过测试用例[4,2,1]32时间复杂度O(n * n!)空间复杂度O(n) 递归调用深度为O(n)class Solution { vector<int> tmp; int ans; void dfs(vector<int>& nums, int target, int sum) { if(sum == target) {

题目链接：leetcode.三重循环，但思路根本就是错的，哎42 / 48 个通过测试用例[5,9,18,54,108,540,90,180,360,720]输出 [9,18,54,108,540]预期结果 [9,18,90,180,360,720]class Solution {public: vector<int> largestDivisibleSubset(vector<int>& nums) { int N = nums.

题目链接：leetcode./*四重循环，好家伙（27 / 27 个通过测试用例），当然超时*/class Solution {public: int maxSumSubmatrix(vector<vector<int>>& matrix, int k) { int M = matrix.size(), N = matrix[0].size(); vector<vector<int>> dp(M+1,

题目链接：leetcode.小破题把孩子整不会了都/*93 / 101 个通过测试用例[3,5,0,3,4]*/class Solution {public: bool find132pattern(vector<int>& nums) { if(nums.size() < 3) return false; int minn = INT_MAX; int maxx = INT_MIN; for(auto x : nums)