HDUCheater的博客

难度不高，但是代码量还是比较多的，锻炼基本功挺不错的。

该说不说的，我觉得写的一气呵成挺完美。

代码】Leetcode_622_设计循环队列_数据结构。

代码】Leetcode_919_完全二叉树插入器_广搜。

代码】Leetcode_558_四叉树交集_递归。

代码】Leetcode_814_二叉树剪枝_递归。

变种补充如果去掉包含0到N-1的所有整数的条件，采用记忆化dfs。

代码】Leetcode_558_四叉树交集_递归。

用两棵Trie的话难度不大，核心是空间换时间的做法，把经过Trie的所有字符串的index存储下来，最后取前缀和后缀匹配list的最大的相等数。至于用一棵树的做法，我个人觉得比较难想到。

最难的部分是抽象出栈这个数据结构

水题

构造trie树即可比较坑的是next数组的判空

class Solution { int[] mp; public boolean isAlienSorted(String[] words, String order) { initMp(order); int len = words.length; for(int i = 0;i < len - 1;i ++) { if(!compare(words[i], words[i+1])) {

在搜索的过程中，如果找到了p就标记一下，如果标记位为true，那么就返回这个值就行了/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { boolean flag;

注意一下可以通过i <= sumOfIndex进行一个剪枝class Solution { public String[] findRestaurant(String[] list1, String[] list2) { Map<String, Integer> map = new HashMap<>(); int len1 = list1.length; int len2 = list2.length;

简单的dp，需要注意考虑0以及只有一个负数的情况class Solution { public int maxProduct(int[] nums) { int temp = 1; int len = nums.length; // 以下标结尾的最大乘积 int[][] dp = new int[len][2]; if(nums[0] > 0) { dp[0][0] = nums[0];

学acm的第一个专题，好怀念改了半天没过，一看题解爆int，气晕import java.util.Scanner;// 一个游戏实际的价格是b - (a - b) = 2 * b - aclass Game { Integer cost; Integer value; public Game(Integer cost, Integer value) { this.cost = cost; this.value = value; }

一开始的思路是找到区间内第一个蜡烛和最后一个蜡烛，最后计算这两个蜡烛之间的盘子数量，当然超时了。那么怎么去优化这两个步骤呢，第一个步骤我采取了记录蜡烛位置的方式，通过二分查找区间上下限，定位到第一个蜡烛和最后一个蜡烛的下标；第二个步骤我采取前缀和数组的方式，记录前i个元素中盘子的个数。class Solution { public int[] platesBetweenCandles(String s, int[][] queries) { int m = queries.len

非常有意思的一道题，我自己一开始做的时候，想了一堆排列策略都是错的，没想到其实就是简单的贪心，如果正着拼接比反着拼接小，肯定正着拼接，哈哈。class Solution { public String minNumber(int[] nums) { int n = nums.length; String[] temp = new String[n]; for (int i = 0; i < n; i++) { temp[

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode head = n

前两天一面的原题，二分还是效率最高的做法，使用那个删行/列复杂度还是有点高class Solution { public boolean findNumberIn2DArray(int[][] matrix, int target) { int n = matrix.length; if(n == 0) { return false; } int m = matrix[0].length; if

特殊情况得多考虑一下class Solution { public String convertToBase7(int num) { if(num == 0) { return "0"; } int temp = num; StringBuilder sb = new StringBuilder(); while(temp != 0) { sb.append(Math.a

很容易观察到是一道动态规划class Solution { public int translateNum(int num) { String s = String.valueOf(num); int len = s.length(); int[] dp = new int[len]; dp[0] = 1; for(int i = 1;i < len ;i ++) { dp[i] = dp

class Solution { public int lengthOfLongestSubstring(String s) { int len = s.length(); if(len == 0) { return 0; } int st = 0; int ed = 0; int ans = 1; boolean[] judge = new boolean[128

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public boolean isSubStructure(TreeNode A, TreeNode B) {

官方用的动态规划，我用的滑动窗口。就是维护一个长度为time+1的递减窗口，将符合要求的窗口尾部放入一个set。然后倒序维护一个长度为time+1的递增窗口，如果符合要求的窗口头部在set中，将其放入答案中。class Solution { public List<Integer> goodDaysToRobBank(int[] security, int time) { Set<Integer> left = new HashSet<>()

我也不知道我是怎么过的？class Solution { public int minArray(int[] numbers) { int len = numbers.length; int l = 1; int r = len - 1; while(l <= r) { int mid = (l + r) >> 1; if(numbers[mid] < numbe

判别是否需要使用单调栈，如果需要找到左边或者右边第一个比当前位置的数大或者小，则可以考虑使用单调栈；单调栈的题目如矩形米面积等等class Solution { public int[] dailyTemperatures(int[] temperatures) { int len = temperatures.length; int[] ans = new int[len]; Deque<Integer> stack = new Lin

class Node { Node pre, next; int key, value; public Node() { } public Node(int key, int value) { this.key = key; this.value = value; }}class LRUCache { Node head, tail; Map<Integer, Node> map;

好像大一打acm写过？无法理解这竟然是一道面试高频题。。class Solution { public String multiply(String num1, String num2) { if (num1.equals("0") || num2.equals("0")) { return "0"; } StringBuilder ans = new StringBuilder("0"); int m = n

将对应数移到对应位上，如果该位上数与要移动的数相同，就找到了，空间O1class Solution { public int findRepeatNumber(int[] nums) { int len = nums.length; int i = 0; while(i != len) { if(i == nums[i]) { i++; } else {

最简单的方法改个set就行了class Solution { Set<List<Integer>> ans; int[] nums; int len; public List<List<Integer>> permuteUnique(int[] nums) { this.nums = nums; ans = new HashSet<>(); len = nums.l

一个个添加，添加满了加入ans，用visit数组记录现在还可以添加的元素下标class Solution { List<List<Integer>> ans; int[] nums; int len; public List<List<Integer>> permute(int[] nums) { this.nums = nums; ans = new ArrayList<>();

with t as ( select user_id, min(activity_date) as login_date from traffic where activity = 'login' group by user_id)select login_date, count(distinct user_id) as user_countfrom twhere DateDiff("2019-06-30", login_date) <= 90group b

with t as ( select s.school_id, e.score from schools as s left join exam as e on s.capacity >= e.student_count)select school_id, ifnull(min(score), -1) as scorefrom tgroup by school_id

# Write your MySQL query statement belowselect d.dept_name, count(s.student_id) as student_numberfrom department as dleft join student as s on d.dept_id = s.dept_idgroup by d.dept_idorder by student_number desc如果直接写的话，很绕的一道题，个人比较喜欢用下面的写法，感觉更加清晰直观w

这个特判属实很坑，绕不过去，题倒是没难度class Solution { public String convert(String s, int numRows) { if(numRows == 1) { return s; } StringBuilder[] sbs = new StringBuilder[numRows]; for(int i = 0;i < numRows;i++) {

一开始想用基数排序，但感觉写起来真的太复杂了，复杂度应该是1e6，算符号一共十位嘛。这个用set的我感觉还得看版本，1.8用红黑树要是冲突太多还真不一定算O(n）做法就是先去重，然后遍历维护ans。如果x-1在set中存在，就不查，等到x-1的时候再查。class Solution { public int longestConsecutive(int[] nums) { Set<Integer> set = new HashSet<>();

学完操作系统，习惯用信号量了class Foo { Semaphore s1, s2; public Foo() { s1 = new Semaphore(0); s2 = new Semaphore(0); } public void first(Runnable printFirst) throws InterruptedException { printFirst.run(); s1.release

看了一眼自己一年前写的多线程，真的惨不忍睹，所以重写了一遍class BoundedBlockingQueue { ReentrantLock mutex; Semaphore isFull; Semaphore isEmpty; LinkedList<Integer> list; public BoundedBlockingQueue(int capacity) { isFull = new Semaphore(capacity);