wcxdell的专栏

这个题第一想法就是递归，然后就写下了下面的代码。分成两部分，然后分别对两部分递归。 TreeNode* util(vector& nums, int left, int right) { if (left > right) return NULL; int max = INT_MIN; int index = right;

一次AC，用的层次遍历，遍历一层的时候记录第一个node int findBottomLeftValue(TreeNode* root) { queueque; que.push(root); TreeNode *leftNode = NULL; int horizinal = 1; int tmpHoriz

把word分割出来分别旋转即可。 void reverseString(string &s,int left, int right) { while (left < right) { char tmp = s[left]; s[left] = s[right]; s[right] = tmp;

字典树是一种处理字符串很重要的树，我写了一个Demo，不会写的同学可以参考看看。头文件自己加吧 :)class TreeNode {public: int val; unordered_map children;};class Tree {public: TreeNode *root; Tree() { root = new Tre

这道题我用后序遍历把所有子树和都放在一个map里面保存，然后找到最大的次数并输出即可。 map m; int houxu(TreeNode *root) { if (!root) return 0; int sum = root -> val; sum += houxu(root->left); sum += hou

这道题把奇数的拿出来，再把偶数的拿出来，连接上即可。 ListNode* oddEvenList(ListNode* head) { if (!head) return head; ListNode *odd = head; ListNode *even = head -> next; ListNode *

这题就是两次攻击间隔小于duration的话就加间隔，否则加duration。注意最后一次和没有的情况即可。 int findPoisonedDuration(vector& timeSeries, int duration) { if (timeSeries.empty()) return 0; int sum = 0; for (i

这个太简单，不说了int findMaxConsecutiveOnes(vector& nums) { int subNum = 0; int max = 0; for (int i = 0;i<nums.size();i++) { if (nums[i] & 0x01) subNum++; els

这道题就是靠位操作，按理说只要返回原来的反就可以了，但是前边的0要过滤掉，所以，要想办法屏蔽前边的0,。然后后边用全部为1的掩码与一下原来的数的反即可。int findComplement(int num) { unsigned int mask = ~0; while(num&mask) mask <<= 1; return ~mask & ~

这题没什么可说的。vector findWords(vector& words) { unordered_set set1 = {'Q','q','W','w','E','e','R','r','T','t','Y','y','U','u','I','i','O','o','P','p'}; unordered_set set2 = {'S','s','D','

这题没什么难的，读懂题就好了，注意k比字符串长和最后剩下的比k小的情况。 string reverseStr(string s, int k) { int pos = 0; while(pos < s.size()) { if (pos + k > s.size()) { k = s.size() -

只要找到第三个数比前两个数大就行了，记录更小的数字。 bool increasingTriplet(vector& nums) { int a = INT_MAX, b = INT_MAX; for (auto num : nums) { if (num <= a) { a = num;

层次遍历，太简单了，一次过。 vector largestValues(TreeNode* root) { queue que; vector vec; if (!root) return vec; que.push(root); while(!que.empty()) { int s

这道题我用了从后往前的思路。如果当前是小写的，上一个是大写的，直接false，否则continue如果当前是大写的，上一个是大写的，continue，否则看当前是不是首尾，不是返回false。6ms，打败70%+ if (word.empty()) { return false; } bool isCapital

这种题不想说什么，注意审题就好了。 bool checkRecord(string s) { int size = s.size(); int L = 0; int A = 0; for (int i = 0 ; i < size ; ++i) { if (s[i] == 'A') {

遍历第二个数组，用一个栈来构建一个数字和next greater一一对应的map即可。 vector nextGreaterElement(vector& findNums, vector& nums) { stack st; unordered_map mp; vector vec; for (int i : nums)

这道题从前往后便利，记录能到达的最大Index，如果发现当前index大于最大index，则不可达。然后判断是否大于了最大index即可。 bool canJump(vector& nums) { int len = nums.size(); int maxIndex = 0; if (maxIndex >= len - 1) retu

动态规划状态转移方程 dp[i][j] += min(dp[i-1][j],dp[i][j-1])一次AC，代码如下： int minPathSum(vector>& grid) { int row = grid.size(); int col = grid[0].size(); for (int i = 1;i<row;i++)

这道题题意很简单，但是容易出错，特别是第一个Node需要删掉的情况，所以可以使用一个dumyNode来做，简单而且不容易出错。 ListNode* deleteDuplicates(ListNode* head) { if (!head || !head->next) return head; ListNode *dummy = new ListNode(

这个就是字典树了，我用unordered_map时间上更节省一些。class TrieNode { public: unordered_map children; bool isLeaf; TrieNode(){isLeaf = false;};};class Trie {public: TrieNode *root; /** Initia

先用简单的方法，中序遍历放到一个数组里面，取k-1即可。 vector vec; void inorder(TreeNode *root) { if (!root) return; inorder(root->left); vec.push_back(root->val); inorder(root->right);

用反过来的中序遍历即可 int sum = 0; void rever(TreeNode *root) { if (!root) return; rever(root->right); root->val += sum; sum = root->val; rever(root->left);

这题我先是用了计数排序，AC。然后看他的要求，不符合，后来看了discussion，把存在的位置变成负数，太妙了，既保留了原有信息，又做了标记。 vector findDisappearedNumbers(vector& nums) { vector result; for (int i = 0;i<nums.size();i++) {

找到中位数，计算每一个数字和中位数相减的绝对值的和即可 int minMoves2(vector& nums) { int count = 0; if (nums.size() == 0) return count; sort(nums.begin(),nums.end()); int midNum = nums[nums.

这道题就是个证明题，证明分解为3的时候最大，不足的地方用2补充。在不知道是3的情况下证明还是挺复杂的，用到了挺多高数的知识，如果只是证明3最好还是比较容易的，这里就不说了。代码如下： int integerBreak(int n) { if (n == 2) return 1; if (n == 3) return 2;

这道题的思路是把数字对应的位置变成负数，既保留了数字大小，也做了标记。当第二次遇到这个位置，发现是负数的时候，直接加入到结果数组中即可。 vector findDuplicates(vector& nums) { vector result; int index; for (int i = 0;i<nums.size();i++) {

这道题我先把两个数组排序，然后用了一个嵌套循环，里循环不是每次都从头开始，而且从上一次跳出的地方开始，可以节省很多时间。 int findContentChildren(vector& g, vector& s) { int count = 0; sort(g.begin(),g.end()); sort(s.begin(),s.end()

这道题我先记录每个字母出现的频率，然后做了一个降序，然后依次赋值给字符串就行了。 static bool compare(paira,pairb) { return a.second>b.second; } string frequencySort(string s) { unordered_map hashMap; vec

这题刚开始也用DFS做，后来发现不对。。。因为要收集的是边的信息。直接扫描就好了，优化一下，因为只从右上开始扫描，所以只对右上两个边进行计算。 int islandPerimeter(vector>& grid) { int num = 0; int rows = grid.size(); int cols = grid[0].size

好久不刷leetcode了，因为找了个还比较满意的实习，今天突然上来发现C++都不会写了。。。还是要保持手感呐。这道题第一思路就是DFS，然而它给了两个要求，一个是不能改变board，第二是只用O(1)的额外空间。先说下修改board的吧。找到一个X之后用DFS把周围的全部变成‘.’就可以了。符合条件的解法是找到X且上边和右边都没有X，很巧妙。代码如下，注意边界，不然就cras

帮别人找bug，顺便把这道题做了，用的是快排的方式。 int findKLargestElement(int k, vector& nums, int low, int high) { int left = low; int right = high; int key = nums[left]; while (left <

这个题有思路，但是太麻烦，后来看了discuss,发现解法very精妙，直接拿来用了，并且熟悉了一下auto和sort函数 vector> reconstructQueue(vector>& people) { vector> result; sort(people.begin(),people.end(),[](paira,pairb){

这题太简单了，不说了，上代码 vector fizzBuzz(int n) { vector result; for(int i = 1;i<=n;i++){ string str = ""; if(i%3 == 0){ str += "Fizz"; }

这个比较简单，就是看有多少个成对的再加上一个落单的就行。 int longestPalindrome(string s) { int count = 0; vector array(130,0); for (char a:s) { array[a]++; } int flag = 0;

这道题之后养成了看tag的习惯，tag真的能给你很大的帮助这道题的tag的math，那应该是有数学方法。把其他的数字+1，相当于把最大的数字-1.所以只要算所有数字和最小数字的差的累加和就可以了 int minMoves(vector& nums) { int count = 0; int min = nums[0]; for

这题太简单了，我用了位运算 int hammingDistance(int x, int y) { int count = 0; while(x!=0||y!=0){ if ((x&0x1) != (y&0x1)) count++; x = x>>1; y = y>>1;

最简单的解法就是3个一组，4个一组这样暴力的去遍历，效率低下。所以通过找规律发现，等差数列每增加一个，总数增加的个数也是一个等差数列。 int numberOfArithmeticSlices(vector& A) { if (A.size()<3) return 0; int count = 0; int phase = 0;

我的第一版解法  回溯法 int sum = 0; bool isUniqueDigit(int num) { if (num<10) return true; int tmp = num % 10; num /= 10; while(num) { if(tmp == num % 10) re

这道题做出来很简单，但是运行时间总是不能小于40ms。看了下discuss，最快的方法就是不用栈，两个指针从后往前走。我是用栈的，但是比别的用栈的慢了不少，最后发现原因是用了太多的临时变量，以后变量还是少用的好。 ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { stack nodeStack1;

前序遍历。一次AC。 vector preorderTraversal(TreeNode* root) { stack stack; vector result; if (!root) return result; stack.push(root); while(!stack.empty()) {