2021年01月__almost__

原创 LeetCode 29. 两数相除

难度：中等。标签：数学，二分查找。第一反应是用减法暴力来做，肯定超时。使用二分的思想，见递归函数。边界值很容易出错，要注意判断。正确解法：class Solution { int div(int a, int b){ if(a < b)return 0; int n = b, m = 0, right = 1, left = 0; while(n < a){ m = n; left

2021-01-30 18:03:10 73

原创 LeetCode 778. 水位上升的泳池中游泳

难度：困难。跟昨天的每日一题 1631. 最小体力消耗路径一样的。并查集正确解法：class UnionfindSet{public: vector<int> parents; UnionfindSet(int n):parents(vector<int> (n)){ for(int i = 0; i < n; i++){ parents[i] = i; } } int fi

2021-01-30 17:10:26 62

难度：中等。好的，这个题我不会。参考官方题解https://leetcode-cn.com/problems/path-with-minimum-effort/solution/zui-xiao-ti-li-xiao-hao-lu-jing-by-leetc-3q2j/二分法正确解法：class Solution { static constexpr int dirs[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};public: int m

2021-01-29 17:50:12 89

原创 LeetCode 26. 删除排序数组中的重复项

难度：简单。正确解法：class Solution {public: int removeDuplicates(vector<int>& nums) { int n = nums.size(); if(n <= 1)return n; int temp = nums[0], end_num = nums[n-1]; int index = 1; for(int i = 1; i <

2021-01-28 19:40:30 24

原创 LeetCode 25. K 个一组翻转链表

难度：困难。比较绕，得想清楚。找到当前k个数中的最后一个，即代码中的end_k_node，如果这个节点存在，则继续下面的替换；否则结束。每次将当前的K组节点的第一个节点放到end_k_node的后面，直到第一个节点为end_k_node为止。正确解法：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : v

2021-01-28 19:06:18 43

原创 LeetCode 24. 两两交换链表中的节点

难度：中等。熟悉链表操作。正确解法：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNode *next)

2021-01-28 17:50:15 93

原创 LeetCode 724. 寻找数组的中心索引

难度：简单。先将数组所有元素的总和算出来，然后逐个遍历并判断。正确解法：class Solution {public: int pivotIndex(vector<int>& nums) { int n = nums.size(); if(n == 0)return -1; if(n == 1)return 0; int sum = 0; for(int i = 0; i < n; i+

2021-01-28 12:40:25 28

原创 LeetCode 23. 合并K个升序链表

难度：中等。重点在链表的操作，不要搞混了。正确解法：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNod

2021-01-26 13:20:12 46

原创 LeetCode 22.括号生成

难度：中等。标签：字符串，回溯算法。与之前LeetCode 17.电话号码的字母组合那道题特别像。正确解法：class Solution { void get_result(vector<string>& result_list, string res, int n, int a, int b){ if(a == n && b == n){ result_list.push_back(res);

2021-01-26 12:34:47 63

原创 LeetCode 1128.等价多米诺骨牌对的数量

难度：简单。这个题的意思怪怪的，不太理解为什么要这样，不过做起来是很简单。用一个二维数组来存储这些数字。正确解法：class Solution {public: int numEquivDominoPairs(vector<vector<int>>& dominoes) { int n = dominoes.size(); if(n <= 1)return 0; int nums[10][10] = {0

2021-01-26 12:09:58 37

原创 LeetCode 19. 删除链表的倒数第 N 个结点

难度：中等。双指针，重点是思路，实现简单。正确解法：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNod

2021-01-25 22:23:22 31

原创 LeetCode 959.由斜杠划分区域

难度：中等。这个题，我不会，看别人的思路。方法一参考：https://leetcode-cn.com/problems/regions-cut-by-slashes/solution/c-dong-hua-zhuan-huan-cheng-dao-yu-ge-sh-guve/然后问题同 200. 岛屿数量，遍历0的区域。我的实现：class Solution { int map[1001][1001] = {0}; void change_map(int i, int j,

2021-01-25 13:04:05 85

原创 LeetCode 674. 最长连续递增序列

难度：简单。class Solution {public: int findLengthOfLCIS(vector<int>& nums) { int n = nums.size(); if(n <= 1)return n; int result = 0; int i = 0; while(i < n){ int j = i + 1, k = 1;

2021-01-24 12:22:57 60

原创 LeetCode 989.数组形式的整数加法

难度：简单。考虑好各种情况就行。class Solution {public: vector<int> addToArrayForm(vector<int>& A, int K) { if(K == 0)return A; int A_num = A.size(); int temp = 0; int a_index = A_num - 1; int m = K;

2021-01-22 20:48:04 42

原创 LeetCode 17. 电话号码的字母组合

难度：中等。标签：深度优先搜索，回溯法，递归。正确解法：class Solution { map<char, string> phone = { {'2', "abc"}, {'3', "def"}, {'4', "ghi"}, {'5', "jkl"}, {'6', "mno"}, {'7', "pqrs"}, {'8', "tuv"}, {'9', "wxyz"}}; void DFS(string digits,

2021-01-21 16:30:43 79 1

原创 LeetCode 1489. 找到最小生成树里的关键边和伪关键边

难度：困难。标签：深度优先搜索，并查集。看了提示，需要用Kruskal算法来计算最小生成树，方法如下：计算最小生成树的权重为minWeightminWeightminWeight。遍历所有边，指定以当前边为最小生成树中的边来构建最小生成树，若构建成功且当nowWeight==minWeightnowWeight == minWeightnowWeight==minWeight 时，则该边为有效边；否则（构建不成功，或构建成功权重变大）为无效边。当边为有效边时，继续，进一步判断其为关键边或非关键边

2021-01-21 12:51:04 183 1

原创 LeetCode 10. 正则表达式匹配

难度：困难。标签：字符串，动态规划，回溯法。使用动态规划的方法，dp[i][j]dp[i][j]dp[i][j]表示sss的前iii个字符串与ppp的前jjj个字符串是否匹配，即dp[i][j]=isMatch(s[0...i−1],p[0...j−1])dp[i][j] = isMatch(s[0...i-1], p[0...j-1])dp[i][j]=isMatch(s[0...i−1],p[0...j−1])括号中为索引，数组dpdpdp的索引范围为dp[0...sn][0...pn]dp[0

2021-01-20 21:41:07 84

原创 LeetCode 18. 四数之和

难度：中等。标签：数组、哈希表、双指针。双指针按照【三数之和】的方法，固定两个数，多加一层循环。正确解法：class Solution {public: vector<vector<int>> fourSum(vector<int>& nums, int target) { int n = nums.size(); vector<vector<int>> result;

2021-01-20 20:21:41 36

原创 LeetCode 16. 最接近的三数之和

难度：中等。标签：数组，双指针。将上一题的代码改一改就可以了。正确解法：class Solution { int my_abs(int a){ return a>=0?a:-a; }public: int threeSumClosest(vector<int>& nums, int target) { int n = nums.size(); if(n == 3)return (nums[0] +

2021-01-20 17:41:37 47

原创 LeetCode 15. 三数之和

难度：中等。标签：数组，双指针。开始没仔细看示例，导致理解有问题，不知道怎么做。之后看了下标签明白了，应该是先排序，后使用双指针来做。加入一些条件可以使程序更快。正确解法：class Solution { void swap(vector<int>& nums, int i, int j){ int k = nums[i]; nums[i] = nums[j]; nums[j] = k; } int

2021-01-20 17:25:23 44

原创 LeetCode 628. 三个数的最大乘积

难度：简单。先排序，再计算。正确解法：class Solution { void swap(vector<int>& nums, int i, int j){ int k = nums[i]; nums[i] = nums[j]; nums[j] = k; } int partition(vector<int>& nums, int left, int right){ i

2021-01-20 13:00:04 33

原创 LeetCode 12. 整数转罗马数字 13. 罗马数字转整数

难度：中等使用贪心的思想。正确解法：class Solution {public: string intToRoman(int num) { string s = ""; vector<string> str_list = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"}; vector<int> int_list = {10

2021-01-18 17:32:09 69

原创 LeetCode 11. 盛最多水的容器

方法一先用遍历的方法来解，设置一些条件可以尽可能地加快速度。解法：class Solution {public: int min_num(int a, int b){ return a<b?a:b; } int maxArea(vector<int>& height) { int n = height.size(); int max_volume = 0; for(int i = 0

2021-01-18 15:48:11 42 2

原创 LeetCode 721. 账户合并

借着这个题学一下并查集。并查集讲解：https://zhuanlan.zhihu.com/p/93647900/参考题解：https://leetcode-cn.com/problems/accounts-merge/solution/tu-jie-yi-ran-shi-bing-cha-ji-by-yexiso-5ncf/正确解法：class unionfindSet {public: vector<int> parent; vector<int> ran

2021-01-18 14:36:14 49

原创 LeetCode 123.买卖股票的最佳时机 |||

难度：困难暴力超时解法首先想到了比较暴力的方法，将数组在不同位置进行分段，然后分别计算两段的最大收益，最后选取最大的那个。思想都在代码里。结果应该是正确，但超时了的解法：class Solution {public: // get the index of max value in prices[left, right] int findMaxIndex(vector<int>& prices, int left, int right){ in

2021-01-09 18:29:05 61

原创 LeetCode 189.旋转数组

难度：中等。本来是很简单的题，但要求空间复杂度为O(1)。因此就需要找规律了，第一次找提交后错了一次。之后发现需要求出数组大小和k的最大公因数d，表明数组中有d组元素互相交换。找最大公因数的方法有三种：暴力法相减法：思路见代码辗转相除法step1. a存放较大的数，b存放较小的数step2. k = a % bstep3. 若k == 0，则b是最大公因数step4. 否则：a = b, b = tempstep 5. 回到step2正确解法：class Solu

2021-01-08 17:15:44 121

原创 LeetCode 4.寻找两个有序数组的中位数

难度：困难。复杂度较高的解法（O(nlogn)）直接合并两个数组后进行快排。class Solution {public: void swap(vector<int>& nums, int i, int j){ int k = nums[i]; nums[i] = nums[j]; nums[j] = k; } int partition(vector<int>& nums, in

2021-01-07 18:53:37 59

原创 LeetCode 547.省份数量

难度：中等。深搜，我用stack解决的。正确解法：class Solution {public: int findCircleNum(vector<vector<int>>& isConnected) { int flag[201] = {0}; int n = isConnected.size(); int num = 0; for(int i = 0; i < n; i++){

2021-01-07 11:53:03 157

原创 LeetCode 9.回文数

难度：简单开始有点问题，溢出了。进阶版，没有将int转换为字符串。正确解法：class Solution {public: int my_pow(int a, int b){ int result = 1; for(int i = 0; i < b; i ++){ result *= a; } return result; } bool isPalindrome(int x)

2021-01-06 22:11:48 54

原创 LeetCode 8.字符串转换整数

难度：中等。没啥难度，就想多一点就好了。考虑不周，导致WA了两次，没考虑下列情况：“000000002322”“00000-42a1234”之后又因为其他小错误交了几次，伤心。正确解法：class Solution {public: int my_pow(int a, int b){ int k = 1; for(int i = 0; i < b; i ++){ k *=a; } re

2021-01-06 21:21:22 125

原创 LeetCode 7.整数反转

难度：中等。主要是对溢出的判断比较麻烦，还要注意正数与负数绝对值的范围不同。INT_MAX: 2147483647INT_MIN: -2147483648正确解法：class Solution {public: int MAX = 2147483647; int my_pow(int a, int b){ int result = 1; for(int i = 0; i < b; i ++){ resul

2021-01-05 22:41:08 48

原创 LeetCode 6. Z字形变换

难度：中等。没啥技巧，就是找规律。可以从周期来考虑，以下述红框内的为一个周期。按照这个周期来找更具体地规律。正确解法：class Solution {public: string convert(string s, int numRows) { int len = s.length(); if(len < 2 || numRows < 2)return s; int midde_num = numRows - 2;

2021-01-05 21:39:18 72

原创 LeetCode 5. 最长回文子串

难度：中等。知道是动态规划，但好久没写代码有点忘了，看了下思路，如下：使用res[i][j]表示s[i]到s[j]是否为回文，则当 s[i] == s[j] 时，res[i][j] = res[ i+1 ][ j-1 ]否则，res[i][j] = 0边界取值：res[i][i] = 1;若s[i] == s[j], 则res[i][i+1] = 1，否则res[i][i+1] = 0计算时第一层循环为遍历步长，第二层遍历i的取值。正确解法：class Solution {pu

2021-01-05 20:52:41 53 1

原创 LeetCode 830. 较大分组的位置

难度：简单。注意一下边界特殊情况，"aaa"等。正确解法：class Solution {public: vector<vector<int>> largeGroupPositions(string s) { int len = s.length(); vector<vector<int>> result; if(len < 3)return result; char now

2021-01-05 20:15:08 42

原创 LeetCode 3.无重复字符的最长子串

难度：中等。不能暴力搜索，用到了动态规划的思想。使用一个数组a存储从每个索引开始的最长子串，则L(i + 1) >= L(i) - 1 从i+1处进行最长字串的计算不用从i+1开始计算，从i+L[i]处进行判断。正确解法：bool is_repetition(char *s, int begin_index, int cur_index){ for(int i = begin_index; i < cur_index; i++){ if(s[i] == s

2021-01-04 21:17:34 67

原创 LeetCode 2. 两数相加

难度：中等题目不难，就是得想清楚链表的连接。两个关键点：生成新的结构体节点要分配内存。 struct ListNode *t1 = (struct ListNode *)malloc(sizeof(struct ListNode));连接l链表必须用当前链表的最后一个节点的next 等于新节点。// l1是最后一个有效节点，l1->next = NULL// rightl1->next = t1;// wrongl2 = l1->next;l2 = t1

2021-01-04 20:46:03 50

原创 LeetCode 1. 两数之和

这是刷的第一道题，因为没看官方给的代码，写了完整的C++代码，包括字符串的处理。正确解法：class Solution {public: vector<int> twoSum(vector<int>& nums, int target) { int num = nums.size(); vector<int> result(2); bool is_end = false; for(int

2021-01-04 19:39:27 40

almost_afei的博客