pppppppyl的博客

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

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

题目链接：leetcode. 我应该做过，，提示说是动态规划emmm 1~n的数字，如果用i作为根节点，那么左子树就是1~i-1，右子树就是i+1~n G(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

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

题目链接：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. 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] + 1 word2插入一个字符 = dp[i][j - 1] + 1 修改字符 = dp[i - 1][j - 1]

题目链接：leetcode. /* 执行用时：12 ms, 在所有 C++ 提交中击败了99.61%的用户 内存消耗：13.9 MB, 在所有 C++ 提交中击败了43.21%的用户 */ class Solution { public: vector<vector<int>> merge(vector<vector<int>>& intervals) { int N = intervals.size(); if(N &lt

题目链接：leetcode. 用时间换空间，提前跳出一下循环，就过了 /* 执行用时：12 ms, 在所有 C++ 提交中击败了58.30%的用户 内存消耗：12.8 MB, 在所有 C++ 提交中击败了5.07%的用户 */ class Solution { public: bool canJump(vector<int>& nums) { int N = nums.size(); vector<bool> dp(N, false

题目链接：leetcode. 能隐约感觉到是动态规划，但具体思路不知道 left[i]记录i左边能取到的最大值，right[i]记录i右边能取到的最大值，那么i处能接到的雨水就是左右两边的较小值与它自己高度的差值 O(n) O(n) /* 执行用时：4 ms, 在所有 C++ 提交中击败了93.86%的用户 内存消耗：13.9 MB, 在所有 C++ 提交中击败了53.36%的用户 */ class Solution { public: int trap(vector<int>&

题目链接：leetcode. 动规思路： dp保存以当前位置结尾的子串有效括号的长度，显然只有在s[i]为')'时才会计算长度，为'('时该子串无效，dp值为0 则s[i]==')'时，可以与s[i-1]组成"()"和"))" "()"：dp[i] = dp[i - 2] + 2 "))"：dp[i - 1]是已经匹配的长度设为t，如果s[i-1-t]是'('，其与s[i]又可以配成有效括号，dp[i] = t + 2 + dp[i - t - 2]（因为会有"()(())"的情况） O(n) O(n) /

题目链接：leetcode. 思路：找到一个尽量靠右的较小值，将它与自己右边的一个最小的较大值进行交换 并将较小值位置右边的数按从小到大排序 实际上，交换后，右边一定是递减的，只需逆序就可 /* 执行用时：12 ms, 在所有 C++ 提交中击败了6.71%的用户 内存消耗：11.6 MB, 在所有 C++ 提交中击败了89.06%的用户 */ class Solution { public: void nextPermutation(vector<int>& nums) {

题目链接：leetcode. 回溯的pop简直把我搞懵了 /* 执行用时：4 ms, 在所有 C++ 提交中击败了72.85%的用户 内存消耗：11.5 MB, 在所有 C++ 提交中击败了54.35%的用户 */ class Solution { vector<string> ans; string tmp; void dfs(int n, int left, int right) { if(left > n || right > n

题目链接：leetcode. 这道题第一反应是用回溯，不知道会不会超时 然后我记得应该是有一个把n3降为n2的方法的，比回溯的时间复杂度是低的 很好，一顿操作猛如虎，结果击败百分五 /* 执行用时：932 ms, 在所有 C++ 提交中击败了5.01%的用户 内存消耗：63 MB, 在所有 C++ 提交中击败了5.01%的用户 */ class Solution { public: vector<vector<int>> threeSum(vector<int>&

题目链接：leetcode. 这个题也是做过的，但一时没想起来要用动态规划 dp[i][j]表示s[0]到s[i - 1]与p[0]到p[j - 1]的匹配情况 如果p[j - 1]是'*'，看s[i - 1]与p[j - 2]是否匹配 匹配的话dp[i][j]可以是dp[i - 1][j]（将s[i - 1]扔掉，组合继续匹配）或dp[i][j - 2]（将组合扔掉，匹配0次） 不匹配的话dp[i][j] = dp[i][j - 2] 如果p[j - 1]不是'*'，则看s[i - 1]与p[j - 1

题目链接：leetcode. 这个题也做过的，印象中是用递归，每次减去小的那个数组的前m个，详见题解 /* 执行用时：40 ms, 在所有 C++ 提交中击败了68.50%的用户 内存消耗：86.9 MB, 在所有 C++ 提交中击败了65.08%的用户 */ class Solution { //不递归，用循环就可以的 int getMSA(vector<int>& nums1, vector<int>& nums2, int k) {

题目链接：leetcode. 嘎嘎，第一题，梦开始的地方;) O(N^2) O(1) /* 执行用时：12 ms, 在所有 C++ 提交中击败了25.64%的用户 内存消耗：8.7 MB, 在所有 C++ 提交中击败了43.38%的用户 */ class Solution { public: vector<int> twoSum(vector<int>& nums, int target) { if(nums.empty())