汋灼的博客

和苏微二面的题有点像，也是按照一个不常规的值来给一组元素做快速排序，找到pivot位置为指定的k时这道题更简单，不需要构造多个容器/** * 对points快速排序，按照每个point(x, y)的 x^2 + y^2的大小 * 找到pivotIdx == k的地方，左边的所有点就是答案 * Runtime: 8 ms, faster than 86.92% * Memory Usage: 47.5 MB, less than 72.21% */class Solution {

本题思路dfsdelta代表累积下来玩家1的分数➖玩家2的分数，在玩家1的turn应该选能让delta较小的一端，在玩家2的turn应该选让delta较大的一端现在的写法效率很低，应该可以对每段区间记忆化搜索，但还没想明白一段区间既有可能是玩家1的turn又有可能是玩家2的turn，怎样保存一段区间两种情况的结果？可参考解答视频：https://www.bilibili.com/video/BV1kW411d7R2?from=search&seid=1606201816724874183

这道题关键：1. 利用字母表的特点，字母是挨个排下来的，每行5个（除了最后一行），所以可以直接计算得出每个字母的位置，无需遍历寻找2. 注意'z'字母的特殊情况，其他字母都是如果算出来两个方向，可以先走任意一个再走另一个，但'z'只有一个方向与其他字母连通，从'z'出来只能先上后右，走向'z'只能先左后下，为了不把'z'的情况单独处理，我们能向上就先向上、能向左就先向左走/** * Runtime: 0 ms, faster than 100.00% * Memory Usage: 37

/** * Runtime: 11 ms, faster than 27.64% * Memory Usage: 41.5 MB, less than 13.36% */class Solution { public int calculate(String s) { char[] sArr = s.toCharArray(); int sign = 1, res = 0; // sign用来记录符号（加上后面的项还是减去），最初默认为1；res表示到当前位.

经典的快速选择算法题目快速选择算法的本质是快速排序算法，但是每确定一个元素的位置，下一次就只需要在其中一侧寻找，而且找到第k大元素就可以停止，比完整排序的效率高一些快速排序算法最优、平均时间复杂度为O(nlogn)，最差时间复杂度为O(n^2)快速选择算法最优、平均时间复杂度为O(n)，最差时间复杂度为O(n^2)/** * 快速选择算法，平均时间复杂度O(n)，空间复杂度O(logn) * Runtime: 7 ms, faster than 25.36% * Memory Us.

class Solution { public String reverseWords(String s) { String[] words = s.split(" "); if (words.length == 0) { return ""; } int left = 0, right = words.length - 1; while(left < right) { ...

没做过想不出来这样的题目居然是二维数组dp/** * 二维数组动态规划 * Runtime: 5 ms, faster than 99.52% * Memory Usage: 42.5 MB, less than 72.90% */class Solution { public int longestCommonSubsequence(String text1, String text2) { char[] text1Arr = text1.toCharArray(.

/** * 先沿主对角线对称，再左右对称 * Runtime: 0 ms, faster than 100.00% * Memory Usage: 39.2 MB, less than 22.65% */class Solution { public void rotate(int[][] matrix) { int n = matrix.length; // 沿对角线翻转 for (int i = 0; i < n; i++) {.

在backTrack中去重很关键，先sort保证相同的元素连在一起当相同的前一个元素已经在前面的路径中出现过，要加入当前元素，以获得重复元素的排列；但如果相同的前一个元素在前面的路径中未出现过，则不加入当前元素，以避免重复/** * Runtime: 3 ms, faster than 37.14 * Memory Usage: 39.7 MB, less than 50.63% */class Solution { public List<List<Intege.

用了prefix sum的思想，之前没用过，感觉很难/** * Runtime: 18 ms, faster than 56.05% * Memory Usage: 42.9 MB, less than 35.03% */class Solution { public int subarraysDivByK(int[] nums, int k) { HashMap<Integer, Integer> map = new HashMap(); // pref.

直接遍历一遍保存最大的三个数、最小的两个数的方式，比排序后再拿出最大的三个数、最小的两个数要快，不浪费/** * 先排序，考虑到三个数可能有正有负，结果会等于nums[0] * nums[1] * nums[len - 1]或nums[len - 1] * nums[len - 2] * nums[len - 3] * 排序再做一定能做对，但是时间复杂度可能比较高，因为没必要整个数组都排序，只需要遍历一遍找到最大的三个和最小的两个值即可 * Runtime: 9 ms, faster than

/** * very elegant code from discuss * Runtime: 0 ms, faster than 100.00% * Memory Usage: 40.6 MB, less than 74.38% */class Solution { int max = Integer.MIN_VALUE; // 更新以每个节点为根节点的子树的最大pathSum public int maxPathSum(TreeNode root) { .

/** * 本质：是不是二部图 * 时间复杂度O(V + E)（图的DFS和BFS时间复杂度都是O(V + E)） * Runtime: 11 ms, faster than 97.38% * Memory Usage: 46.7 MB, less than 84.82% */class Solution { public boolean possibleBipartition(int n, int[][] dislikes) { List<Integer>.

/** * 自己的代码，感觉思路不够清晰、代码不够简洁 */class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode sentinel = new ListNode(0), pre = sentinel; int plus1 = 0; // 用来记录低一位是否有进位 // 先处理两个链表都有数据的位 while (...

LRU设计，双向链表 + HashMap<Integer, DBNode>/** * Runtime: 24 ms, faster than 17.52% * Memory Usage: 57.2 MB, less than 5.09% */class LRUCache { class DBNode { // 双向链表节点 int key, val; DBNode pre, next; public DBN.

思路：最简单的是，直接开辟一个新的n*n矩阵，input[i][j] = res[j][n-1-i]，但是这样的空间复杂度0(n^2)太高了。好的解法是，将旋转90度分解为两个对称操作：先沿主对角线对称，再沿中轴线左右对称，这样时间复杂度仍为0(n^2)，空间复杂度降为0(1)。import java.util.*;public class Solution { public int[][] rotateMatrix(int[][] mat, int n) {

苏州微软18冬季实习：https://blog.csdn.net/legend94rz/article/details/84678828?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-0&spm=1001.2101.3001.4242用switch选择每个月的天数2月还要判断闰年（四年一闰，百年不闰，四百年再闰），闰年29天，平年28天import java.util.Scanner;public c