还是不舒服地早醒了，好像怎么着都舒服不起来，发现其实处于这种低价值感的工作状态下，大家心里都不舒服，谁意识到自己可能会一直做琐碎的事情，打杂，几乎没有混出头的希望，只有年龄越来越大，都会有失落感和不安全感吧，只能借助一些事情来麻痹自己，转移注意力，不要思考自己的职业发展，比如投身于家庭生活中，发展兴趣爱好，做副业（这个赚到钱很难），也是一种出路，只要自己能说服自己，不要长期处于痛苦的状态中就行了。长期处于痛苦之中，是很难坚持下去的，要么精神扛不住先奔溃了，要么最终因为一个毫不起眼的导火索破釜沉舟了，缓慢和持续的钝痛比短暂而尖锐的疼痛还要难熬，因为不至于无法忍受，却又时时刻刻无法摆脱，甚至可以超越换语言，刷题，重新浏览岗位信息，从头开始的痛苦和恐惧。

今日进度：
1.强行把查找表剩下的课程都看完了，把练习题集中起来刷掉，居然效率比听一节课刷完课后题来得高，看来以后可以继续这种模式，即集中听课，做笔记，再集中刷题，这样也可以加快刷题进度，只是刷题刷到最后头脑都木了，甚至记不住上一道刷了什么，需要每道题做好笔记，定期复习。

2.坚持录小王子，顺便又探索了一下英文配音，不得不感慨，声音主播的行业真是太卷了，跟着音频练练语感也不错，有时间也可以找一些英文美文读一读

3.坚持锻炼，周末照例户外散步了，但是计划的每日运动没有完成，晚上的时间似乎总是不够用，好像一眨眼就过去了，都不知道干什么去了

4.开始浏览招聘信息，以前总是静不下心来看岗位的具体描述，总是看一两个关键词就开始盲目投递，现在即使一百多页的岗位都有耐心点开一条一条看有没有和自己匹配的，点完手已经酸了，还真是人生的动力来自于生活的艰难啊

5.不管怎么样被泼冷水，都要相信自己，要坚持努力下去，虽然不是所有的努力都一定有回报，甚至可以说大部分人的努力没有回报，但是什么都不做，眼睁睁看着时间过去，是绝对没有希望的，就算没有用，也比不尝试好啊

学习笔记：
1.447回旋镖的数量
给定平面上 n 对 互不相同 的点 points ，其中 points[i] = [xi, yi] 。回旋镖 是由点 (i, j, k) 表示的元组 ，其中 i 和 j 之间的距离和 i 和 k 之间的欧式距离相等（需要考虑元组的顺序）。

返回平面上所有回旋镖的数量。

输入：points = [[0,0],[1,0],[2,0]]
输出：2
解释：两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]

解题思路记录其余点到i的距离出行的频次，避免出现浮点型，使用两点间距离的平方，取两个数可能性为n*(n-1)，时间复杂度为O（N ^2)，空间为O（N），对每一个轴点开一个查找表，用完之后即丢弃。设置一个新的方法，计算距离

class Solution {
    public int numberOfBoomerangs(int[][] points) {
        int res = 0;
        for(int i=0; i<points.length; i++){
            Map<Integer, Integer> m = new HashMap<Integer, Integer>();
            for(int j=0; j<points.length; j++){
                if(i != j){
                    int dis = distance(points[i], points[j]);
                    int freq = m.getOrDefault(dis, 0) + 1;
                    m.put(dis, freq);
                    }
            }
            for(Integer value: m.values()){
                res += value*(value-1);
            }
        }
        return res;
    }

    public int distance(int[]p1, int[]p2){
        return ((p1[0]-p2[0])*(p1[0]-p2[0]) + (p1[1]-p2[1])*(p1[1]-p2[1]));
    }
}

2.220. 存在重复元素 III
给你一个整数数组 nums 和两个整数 k 和 t 。请你判断是否存在 两个不同下标 i 和 j，使得 abs(nums[i] - nums[j]) <= t ，同时又满足 abs(i - j) <= k 。

如果存在则返回 true，不存在返回 false。

输入：nums = [1,2,3,1], k = 3, t = 0
输出：true

解题思路：使用滑动窗口，增加了v-x的绝对值<=t的条件，有顺序的集合存储，使用（long)转换为64位整数，集合里ceiling（v-t）<= v+t，即可确定在左边长K个元素中一定存在元素落在 [x-t,x+t] 时间复杂度O（N log（min(n,k)))空间复杂度O（min(n,k))

class Solution {
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
        TreeSet<Long> ts = new TreeSet<Long>();
        for(int i=0; i<nums.length; i++){
            Long c = ts.ceiling((long)nums[i]-(long)t);
            if(c!=null && c<=(long)nums[i]+(long)t){
                return true;
            }
            else{
                ts.add((long)nums[i]);
            }
            if(ts.size() > k){
                ts.remove((long)nums[i-k]);
            }
        }
        return false;
    }
}

3.219. 存在重复元素 II
给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。

输入：nums = [1,2,3,1], k = 3
输出：true

解题思路：在窗口l到l+k中是否能找到两个相同的元素，可以使用set查找表，表的大小为k,时间复杂度为O（N），空间复杂度为O（N）

class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        Set<Integer> s = new HashSet<Integer>();
        for(int i=0; i<nums.length; i++){
            if(s.contains(nums[i])){
                return true;
            }
            else{
                s.add(nums[i]);
            }
            if(s.size()>k){
                s.remove(nums[i-k]);
            }
        }
        return false;
    }
}

4.217. 存在重复元素
给定一个整数数组，判断是否存在重复元素。

如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

输入: [1,2,3,1]
输出: true

解题思路：使用查找表，将遍历到的元素在查找表里查找，如果有，就重复，没有就加入查找表。

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> s = new HashSet<Integer>();
        for(int i=0; i<nums.length; i++){
            if(s.contains(nums[i])){
                return true;
            }
            else{
                s.add(nums[i]);
            }
        }
        return false; 
    }
}

吃完药又开始不可抑制的困了，还有好多事情都没做，还没锻炼，也没洗澡，但是到了睡觉的时间了，只能明天早点起来做了，明日继续更新。