Warms的博客

题目哈希表推导出映射关系使用哈希表求解：假设A的总和为sumA, B的总和为sumB，交换元素x， y后A、B总和相等，即sumA−x+y=sumB−y+x,化简得：x=y+(sumA−sumB)/2sumA - x + y = sumB - y + x,化简得： x = y + (sumA - sumB) / 2sumA−x+y=sumB−y+x,化简得：x=y+(sumA−sumB)/2,将A中元素加入哈希表，遍历B中元素，如果符合上述映射关系，则找到了交换得一对元素。class Solut

题目https://leetcode-cn.com/problems/word-search-ii/字典树思路:使用深度优先搜索，遍历以各个字符开头的字符串，如果字符串存在于words列表中则加入答案。可以发现如果字符串的前缀不存在于字符串列表中，那么就不用继续搜索了，因此可以使用字典树进行优化。class Solution { private List<String> ans = new ArrayList<>(); private int[][]

题目https://leetcode-cn.com/problems/similar-string-groups/并查集由题目可知，只要两个字符串相似则它们属于同一个连通分量，可以通过并查集维护连通分量的个数，最后返回。class Solution { public int numSimilarGroups(String[] strs) { int n = strs.length; UnionFind uf = new UnionFind(n);

题目https://leetcode-cn.com/problems/design-add-and-search-words-data-structure/前缀树在遇到 “.” 的时候，使用递归方法，将该结点的每一个分支都看过去，只要有一个分支返回 true 就可以了，全部分支都走过去，都没有返回 true 的才返回 false。class WordDictionary { private TrieNode root; class TrieNode { bo

题目https://leetcode-cn.com/problems/integer-to-roman/贪心算法罗马符号由7个字符构成，每个字符都有自己对应的数值，根据减法规则一共有13个独特的字符。为了表示一个整数尽可能选取大的罗马字符，然后不断减去这个字符值到当前数值小于当前罗马字符的值，不断重复这个过程直到数值为0。class Solution { private int[] values = new int[]{1000, 900, 500, 400, 100, 90, 50,

题目https://leetcode-cn.com/problems/reverse-words-in-a-string-iii/字符串操作 双指针class Solution { public String reverseWords(String s) { char[] s2arr = s.toCharArray(); int start = 0; for (int i = 0; i <= s2arr.length; i++) {

题目https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/并查集对于Alice来说当图中只有Alice的独占边和公共边时要求整个图是连通的，也就是说整个图的连通分量只有一个。同理，对于Bob来说当图中只有Bob的独占边和公共边时也要求整个图是连通的。题目要求删除最多的边，也就是要保留最少的边，可以通过给含有n个节点的无向图添加边来满足上面的要求。添加边的策略是优

题目https://leetcode-cn.com/problems/number-of-equivalent-domino-pairs/计数统计等价的二元对有多少个，把二元对转化为相同的格式，即第一维不大于第二维，由于二元对的元素都不大于9所以，二元对可以转化为一维 即 10 * x + y，这样用一个长度为100的数组即可class Solution { public int numEquivDominoPairs(int[][] dominoes) { int[]

题目https://leetcode-cn.com/problems/find-the-duplicate-number/solution/二分查找二分要弄清楚找的是什么，然后再确定查找的范围，然后确定如和缩小区间。抽屉原理：桌上有十个苹果，要把这十个苹果放到九个抽屉里，无论怎样放，我们会发现至少会有一个抽屉里面放不少于两个苹果。这题我们要查找的是一个整数，改整数的范围在[1, n]，由抽屉原理可知如果数组中的元素小于等于 mid 的个数 严格大于 mid 则重复元素一定在[1,mid]

题目https://leetcode-cn.com/problems/intersection-of-two-arrays-ii/哈希表使用一个哈希表对一个数组中的元素进行计数，为了降低时间复杂度选择较短的数组进行计数，计数完成后遍历另一个数组，如果哈希表中存在当前元素则加入答案，并使该元素的数量减1class Solution { public int[] intersect(int[] nums1, int[] nums2) { int len1 = nums1.l

题目https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/二分查找解题关键：通过nums[mid] 与 nums[hi] 的大小关系来缩小搜索区间class Solution { public int findMin(int[] nums) { // 确定搜索范围[lo, hi] int lo = 0; int hi = nums.length -

题目https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence/动态规化要注意题目中的连续二词，使用cur变量维护当前连续子序列的长度，maxLen维护最长连续子序列的长度，如果当前连续子序列是递增的则使cur++并更新maxLen，如果连续子序列递减了则重新将cur置为一。class Solution { public int findLengthOfLCIS(int[] nums) {

题目https://leetcode-cn.com/problems/add-to-array-form-of-integer/逐位相加取出K的最后一位与A的最后一位相加，如果发生进位则将进位加在K上class Solution { public List<Integer> addToArrayForm(int[] A, int K) { List<Integer> ans = new ArrayList<>(); i

题目https://leetcode-cn.com/problems/find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree/Kruscal算法先用Kruscal算法计算其中一棵最小生成树的权值v，使用并查集维护连通分量。然后遍历每一条边，去除该边重新生成最小生成树，如果最后连通分量不为1或者权值nv > v那么这条边就是关键边，然后continue。判断是否是伪关键边可以先将当前遍历的边使用并查集进行合并，然后

题目https://leetcode-cn.com/problems/sort-an-array/快速排序class Solution { public int[] sortArray(int[] nums) { sort(nums, 0, nums.length - 1); return nums; } private void sort(int[] nums, int l, int r) { if (l >= r

题目https://leetcode-cn.com/problems/search-in-rotated-sorted-array/二分查找二分查找的最终目的是要减半搜索，这题通过判断左右端点的值可以判断哪一部分是有序的。如果target在有序部分则在有序部分查找，否则在无序部分查找。class Solution { public int search(int[] nums, int target) { return searchHelper(nums, target,

题目https://leetcode-cn.com/problems/min-cost-to-connect-all-points/Kruscal算法最小生成树：图的生成树是他的一棵含有所有顶点的无环连通子图。一幅加权图的最小生成树(MST)是它的一棵权值最小的生成树。题目可以转换为求最小生成树的权值总和Kruscal算法流程:将图G={V,E}G = \{V, E\}G={V,E} 中所有的边按照从小到达排序，等长的边任意排序初始化图G′为{V,、∅}G'为 \{V, 、\v

题目https://leetcode-cn.com/problems/accounts-merge/并查集账户之间只要有一个邮箱相同那么就是同一个账户，也就是同属一个连通分量因此可以使用并查集。由于并查集底层使用了数组，需要知道一共有多少个不同的邮箱，因此可以使用哈希表给每个邮箱编号，并使用哈希表记录每个邮箱对应的姓名。遍历所有账户，对每个账户的邮箱进行合并就能知道合并完成后一共有几个账户。查询每个邮箱对应哪一个账户（连通分量）将其添加到该账户的列表下，然后将每个列表排序后，使用某个邮箱查询对应

题目https://leetcode-cn.com/problems/check-if-it-is-a-straight-line/submissions/数学以第一个点P0为参照将所有的点平移（-P0x，-P0y），那么直线过原点，Ax + By = 0,A = P1y, B = -P1x, 遍历之后的所有点代入直线公式即可class Solution { public boolean checkStraightLine(int[][] coordinates) {

题目https://leetcode-cn.com/problems/most-stones-removed-with-same-row-or-column/并查集移除石头的过程其实就是有个逆向深度优先搜索或者广度优先搜索的过程。石子的横坐标相等或纵坐标相等相当于在石子之间形成了边。同一个连通分量的石子一定能移除到只剩下一块，所以题目可以转化为求连通分量的个数，而题目给的输入数组是石子的坐标，因此可以考虑使用并查集。并查集中「合并」的语义是：所有横坐标为 x 的石头和所有纵坐标为 y 的石头

题目https://leetcode-cn.com/problems/unique-binary-search-trees/动态规化令G(n)为n个节点能够组成二叉搜索树的数量，F(j,n)：以j为根节点长度为n的二叉搜索树的数量。 G(n) = F(1, n) + ... + F(j, n) +...+ F(n, n ), F(j, n) = G(j - 1) * G(n - j) 所以G(n) = G(1 - 1) * G(n - 1) +...+G(j - 1) * G(n - j) +.

题目https://leetcode-cn.com/problems/binary-prefix-divisible-by-5/模拟i > 1时N_i = N_i-1 * 2 + A[i]，由于A很长所以需要注意溢出的情况，N_i = （N_i-1 * 2 + A[i]）mod 5class Solution { public List<Boolean> prefixesDivBy5(int[] A) { int n = A.length;

题目https://leetcode-cn.com/problems/sort-items-by-groups-respecting-dependencies/拓扑排序每个项目之间存在执行的先后顺序，因此可以对项目拓扑排序得到一个列表。 项目与组是一对多的关系也可以对组进行一个拓扑排序的到组的先后顺序。由项目的拓扑排序可以得到组与项目的一对多的关系，将组的拓扑排序替换为项目的拓扑排序即可得到结果。class Solution { public int[] sortItems(int n

题目https://leetcode-cn.com/problems/redundant-connection/并查集在一棵树中，边的数量比树的结点少一个。这道题中的图在树的基础上多了一条附加的边，因此边的数量也是 N。使用并查集来查找附加的边。一开始所有结点都属于各自独立的一个连通分量，遍历每一条边，如果两个结点属于不同的连通分量则将两个结点合并，合并的两个结点已经属于同一个连通分量则说明这条边是附加的。class Solution { private int[] parent;

题目https://leetcode-cn.com/problems/summary-ranges/solution/hui-zong-qu-jian-by-leetcode-solution-6zrs/双指针需要注意溢出的情况，因此不能做减法判断相邻数的增量是否为1class Solution { public List<String> summaryRanges(int[] nums) { int n = nums.length; Lis

题目https://leetcode-cn.com/problems/rotate-array/数组翻转数组元素向右移动k次后，数组最后的k mod n个元素会移到数组前部例如 [1,2,3,4,5,6,7] ， k = 3先将整个数组翻转得到[7,6,5,4,3,2,1]再将[0,k-1]个元素翻转[5,6,7,4,3,2,1]再将[k, n - 1]个元素翻转[5,6,7,1,2,3,4]class Solution { public void rotate(int[

题目https://leetcode-cn.com/problems/evaluate-division/并查集class Solution { public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) { int equationsSize = equations.size(

题目https://leetcode-cn.com/problems/satisfiability-of-equality-equations/并查集由题可知等式关系具有传递性，==可以看作链接两个顶点的边，如果 a==b,b==c那么a==ca==b, b == c 那么 a == ca==b,b==c那么a==c所以相等的分量同属于一个连通分量，可以使用并查集来维护这种连通分量的关系。首先遍历所有等式，将顶点合并构建并查集再遍历所有不等式，通过并查集判断两个顶点是否连通，如果连通则产生

题目https://leetcode-cn.com/problems/positions-of-large-groups/一次遍历使用一个变量num记录当前分组的长度num初始值为1，如果当前字符与之前的字符不同或者当前遍历到了数组尾部则判断num的大小如果num >= 3，则加入答案，其他情况使num++.class Solution { public List<List<Integer>> largeGroupPositions(String s) {

链接: https://leetcode-cn.com/contest/weekly-contest-222/第一题:贪心class Solution { public int maximumUnits(int[][] b, int m) { int n = b.length; Arrays.sort(b, (o1, o2) -> o2[1] - o1[1]); int res = 0; for (int i = 0;.

题目https://leetcode-cn.com/problems/partition-list/解法直观想法是使用两个哑节点，按顺序遍历输入的链表将小于x与大于x的节点分别添加在两个哑节点尾部，最后将两个哑节点所在的链表组合起来。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) {

题目https://leetcode-cn.com/problems/last-stone-weight/最大堆维护一个大顶堆，每次取出两个石头进行销毁，将销毁后剩余的石头重新加入堆中。class Solution { public int lastStoneWeight(int[] stones) { PriorityQueue<Integer> queue = new PriorityQueue<>((o1, o2) -> o2 - o

题目贪心class Solution { public int minPatches(int[] nums, int n) { int patches = 0; // x为缺失的数字 int len = nums.length, index = 0; // 假设[1, x)之间的数字全部被覆盖，添加x后覆盖范围扩大至[1, 2x) long x = 1; while (x <= n) {

题目https://leetcode-cn.com/problems/isomorphic-strings/哈希表此题与第 [leetCode]290.单词规律思路一样，都利用“双射”，在这题中是指s中的每个字符与t中的每个字符唯一对应，t中的每个字符与s中的每个字符唯一对应，因此可以使用哈希表，在遍历字符串字符的过程中记录两者对应关系，如果出现冲突则返回false。这里的冲突是指哈希表中t映射到s中的字符不等于当前位置s的字符，或者 哈希表中s映射到t中的字符不等于当前位置t的字符。clas

题目https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/滑动窗口维护左右两个指针，动态控制窗口大小，right指针控制窗口扩大，left指针控制窗口缩小，要注意区间为[left, right) ，左闭右开。一开始右指针向右移动，使用Map维护当前元素最后出现位置的下标，如果Map中不存在当前字符则更新Map与字符串长度curLen。右指针在向右移动过程中如果遇到了Map中已经存在的字符

题目https://leetcode-cn.com/problems/first-unique-character-in-a-string/哈希使用数组统计每个字符出现的次数，从左向右遍历字符串寻找第一个只出现一次的字符，并返回其下标。class Solution { public int firstUniqChar(String s) { int[] map = new int[26]; for (char c : s.toCharArray()) {

题目https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/滑动窗口此题与 【567.字符串排列】解法一样。class Solution { private List<Integer> res = new ArrayList<>(); public List<Integer> findAnagrams(String s, String p) { int le

题目https://leetcode-cn.com/problems/minimum-window-substring/滑动窗口定义左右指针控制窗口内元素增减，也就是控制了窗口向右移动。首先，右指针向右移动知道窗口内的字符串包含了t中的所有字符。然后控制左指针向右移动缩小窗口，直到窗口内元素不包含t中所有字符，在移动左指针更新最小长度。判断窗口内元素是否包含t中所有字符可以使用一个变量valid如果窗口内右指针指向元素的个数小于t中该元素的个数则valid++,如果窗口内的字符串包含了t中所有元

题目链接：https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。例如：给定二叉树 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7返回锯齿形层序遍历如下：[ [3], [20,9], [1

题目https://leetcode-cn.com/problems/open-the-lock/BFS锁的每一个数字都可以代表一个节点，锁一共右四个拨轮，每个拨轮有两个选择: 向上拨，这样每个节点与8个节点相连，这就相当于一幅图，题目要求的是求最小的次数，因此可以利用广度优先搜索的特性。搜索过程中有一些点需要跳过: 1. 已经走过的的点，防止死循环； 2. deadends中的点。class Solution { public int openLock(String[] deaden