By

第二季的视角来到了港口，港口发生了一起14个女人在集装箱内全部死亡的案子，一点点揭开了一个大的贩毒团伙。
几组人
港口组，弗兰克带领的港口工会，通过职务之便，偷一些货箱，帮贩毒团伙偷运一些东西。港口生意逐渐萎缩，他想通过修通运河，来增加港口生意。弗兰克是个悲剧的人物，他想带领港口重新繁荣，积极疏通关系，对于下属负责，下属出事，自己垫付钱财，只是偷偷运一些货物出去，恶从一点点积累，逐渐到他无法控制。他的儿子是个缺爱的孩子，一直想证明自己，但总是被嘲笑，最后枪杀了没给他偷车赃款的毒贩，也把自己毁了。他的侄子尼克，聪明，一直帮叔叔跟毒贩联系，但在缺钱的时候，也动起了贩毒的歪脑筋，最后做了污点证人。

贩毒组，这次的毒贩是与西区的乔有关，他们是乔的货的来源。领头的是希腊人，神秘，连姓名都不知道。在FBI有内线。他们通过弗兰克走私毒品、妓女等，最后头目还是脱逃。

警察组这边，是北区的警长在给教会捐玻璃的时候，发现弗兰克已经捐了一块比他还贵的，结了仇，才与副局长交易，成立专案组，但开始大家都不重视，需要一个能力比较强的人，这个时候才将丹尼斯这帮人又都叫了回来，成立的专案组。

第二季整体感觉没有第一季精彩，但毒贩更隐蔽，人物依然鲜活。港口组让人唏嘘，从小恶开始，一点点积聚成大恶，最后危害自己。

By

看完了 书中第二部分《在系统上运行》的链接
这章讲的是软件的编译过程，程序是如何编译的，编译的几个过程，最后怎么链接成一个可执行文件。
整体阅读延续的之前的风格，先了解大概，对于c语言的缺乏，导致我还是不能太理解整个过程，只能说有一个大致的印象吧。摘抄部分原文。
链接（linking） 是将各种代码和数据片段收集并组合成为一个单一文件的过程，这个文件可被加载到内存并执行。
链接器在软件开发中扮演着一个关键的角色，因为它们使得分离编译成为可能。
了解链接的益处

  • 理解链接器将帮助你构建大型程序
  • 理解链接器将帮助你避免一些危险的编译错误
  • 理解链接将帮助你理解语言的作用域规则是如何实现的
  • 理解链接将帮助你理解其他重要的系统概念
  • 理解链接将使你能够利用共享库

By

题目

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。

  1. 1 阶 + 1 阶
  2. 2 阶
    示例 2：
    输入： 3
    输出： 3
    解释： 有三种方法可以爬到楼顶。
  3. 1 阶 + 1 阶 + 1 阶
  4. 1 阶 + 2 阶
  5. 2 阶 + 1 阶
    来源：力扣（LeetCode）
    链接：https://leetcode-cn.com/problems/climbing-stairs
    著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

第一种 动态规划

看答案，自己没想出动态规划的方程
思路1
动态规划
dp[i] = dp[i-1]+dp[i-2]

1
2
3
4
5
6
7
8
9
10
11
12
class Solution {
    public int climbStairs(int n) {
        if(n == 1)return 1;
        int[] dp = new int[n+1];
        dp[1] = 1;
        dp[2] = 2;
        for(int i = 3 ; i <= n ; i++){
            dp[i] = dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}

第二种 暴力法

思路2
暴力法，超时，需要加上记忆法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
    public int climbStairs(int n) {
        int[] bomb = new int[n+1];
        return climb(0,n,bomb);
    }
    private int climb(int i , int n,int[] bomb){
        if(i > n)return 0;
        if(i == n)return 1;
        if(bomb[i]>0){
            return bomb[i];
        }
        bomb[i] = climb(i+1,n,bomb)+climb(i+2,n,bomb);
        return bomb[i];
    }
}

By

看完了第一部分 程序结构和执行
中的信息的表示与处理还有程序的机器级表示
信息的表示和处理这章节是讲编码的，进制的转换，整数、浮点数的运算，这一遍基本上是了解，粗粗的过一遍，很多东西没有细扣，先大致浏览，等第二遍再专项。
程序的机器级表示讲的是，汇编语言怎么处理各种指令的，通过学习汇编各个指令，能很好的理解系统是如何处理c语言的各个过程，从底层去了解编译器的操作，如果遇到某些不能理解的问题，可能是编译器的优化，这个时候就可以看汇编代码去了解，导致编译成了什么可执行语句。
这本书中例子很多，很棒，看了启发很大。

By

这一季从迪奥的杀人审判案说起，讲警方与艾文贩毒团伙的周旋，不算一个新故事，但故事却很吸引人。出场人物众多，但都有不同的性格，在整体的大环境下，各自发展，先有人物后有剧情，不按观众喜好安排剧情。每个角色都有自己的性格，大部分人随着大势走，部分人制造混乱，逆势而行，这样既有序，又有惊喜。
这一季出现几个团体的人员，
警察组，警察作为公务人员，很多人都是一心向上攀，副局长想从政，怕得罪参议员，主动结束案件的深入调查，很多人不出力，只上班打卡，整体颓废，这是警察的大势。其中的个例，主角麦克纳提，是一个好警察，但生活一团糟，为了达到目的不择手段，他将艾文集团越级上报给法官，才引发了对这个大毒枭的调查，但也得罪很多人。缉毒组，丹尼斯督查及其组员，因此牵涉其中，开始他也只想应付，但后年看清楚案件的性质，逐渐负责，主动替下属担下责任。这一小撮人是警察届的清流，负责认真的查案。
毒贩组，艾文集团，老大艾文多疑，心狠手辣，但重视家人，帮侄子迪奥，买通证人，翻案。老二，斯丁格，智囊团，读着大学，融入到正常社会里，在团里很特别。老大的侄子迪奥是一个正直的人，但被迫卷入家族产业中，经历了几次团伙残忍杀入行为后，想要脱离那里，但被迫进监狱顶罪。底层毒贩，平房区的人，都一些未成年人，有些也是生活所迫，卷入这场洪流中。
奥马尔算是毒贩里的奇葩，专门打劫毒贩，凭借智慧，有点罗宾汉的意思，有原则，不恃强凌弱。因为抢劫艾文的货，与艾文结仇，手下相继被杀，单人与艾文集团周旋。
警察的线人，巴布斯，靠小偷小摸换毒品，看到伙伴被毒贩打伤，做了线人，帮警察掌握毒贩信息。想戒毒，但因为格雷斯被枪击，又重入。

整个事件从麦克纳提向法官告状开始，他也许只想调查这个隐秘的毒贩，但他越级报告，触犯了上级，上级不关心毒贩，只想做做样子，前期一直阻挠，不给资源，不让多调查。经过重案组的不懈努力，发现重大线索，他们监视平房区的迪奥，监听电话，弄清楚了毒贩的行动，毒贩与政客勾结，再度阻挠调查，最终艾文被抓，迪奥厌倦了这样的生活，供出整个团伙，但最终因为家庭的考虑，顶了罪。罪犯虽然被抓，但罪很轻。麦克纳提被调到水警组，丹尼尔斯被调到证物组，正义没有成功，反而收到了打击。生活是关联的，剧集深入探讨社会问题，很多问题没有那么简单明了，很多因素纠缠在一起，毒贩与参议员，参议员与局长，局长与警长，一环扣一环。毒贩也不是一无是处，甚至比警察看起来更像好人，警察腐败。 就像迪奥，开始很想参与家族业务，但看到因为自己，证人被杀，只因为看见了他，他没有做假证。很多人因为一点事就被杀，他的小弟是他崩溃的最后一根稻草，他不想参与其中，但逃不掉还是被卷入其中。麦克纳提做事没有底线，得罪上司，与其他人偷情，为了查案不择手段，是一个好警察，但生活一塌糊涂。相反奥马尔，虽然是毒贩，但却又底线，反而被大家认可。做人做事要有底线，它让你不会错得太离谱。

By

题目

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。
示例 1:
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:
输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

思路1
二次二分查找，一次找最小点，一次查找数据是否存在

执行用时 :2 ms, 在所有 Java 提交中击败了85.70%的用户
内存消耗 :36 MB, 在所有 Java 提交中击败了86.28%的用户

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
class Solution {
    public int search(int[] nums, int target) {
        if(nums == null || nums.length == 0)return -1;
        if(nums.length == 1){
            if(nums[0] == target){
                return 0;
            }else{
                return -1;
            }
        }
        int min = getMin(nums);
        int result = -1;
        if(min == 0){
            result = binarySearch(nums,0,nums.length-1,target);
        }else{
            if(target < nums[0]){
                result = binarySearch(nums,min,nums.length-1,target);
            }else{
                result = binarySearch(nums,0,min -1,target);
            }
        }
        return result;
    }
 public int getMin(int[] nums){
        int left = 0;
        int right = nums.length-1;
        if(nums[left]< nums[right]){
            return 0;
        }
        while(left<= right){
            int pivot = (right - left)/2+left;
            if(nums[pivot] > nums[pivot + 1]){
                return pivot + 1;
            }else{
                if(nums[pivot] < nums[left]){
                    right = pivot - 1;
                }else{
                    left = pivot + 1;
                }
            }
        }
        return 0;
    }
public int binarySearch(int[] nums,int left, int right,int target){
        if(target < nums[left] || target > nums[right])return -1;
        while(left <= right){
            int pivot = (right-left)/2 + left;
            if(nums[pivot] == target){
                
                return pivot;
            }else{
                if(nums[pivot] > target){
                    right = pivot - 1;
                }else{
                    left = pivot + 1;
                }
            }
        }
        return -1;
    }
}

By

看了第一章的计算机系统漫游和第二章的信息的表示和处理。

第一章很有意思，讲述了“hello world”这个简单程序的生命周期。
先是讲解程序的编译过程，源文件hello.c经过预处理器，插入一些头文件，编成了hello.i,经过编译器编译成汇编hello.s,再经过汇编器编程成机器码，最后经过链接器，链接全局库文件，成为可以运行文件。

然后是计算机如何执行二进制文件的，cpu读取键盘输入IO到内存，然后，cpu通过总线，加载磁盘IO，读取二进制文件到主存，再读取到暂存，操作系统执行程序，最后将结果返回给显示IO，给屏幕显示。

其中有几个概念很有趣，文件是对IO的抽象，虚拟内存是对主存、IO的抽象，进程是对CPU，主存，IO的抽象。生动简单明了。

信息处理主要是数学与计算机表示的转换，进制转换，程序语言中数字的处理等。

继续深入学习，这本书有点厚，但挺有意思的。

By

题目

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：
输入: “cbbd”
输出: “bb”
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

思路1

题目两个部分，一个部分是找到子串，一个是子串是回文
会问用双指针判断
通过找到重复字符，来排查子串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class Solution {
    public String longestPalindrome(String s) {
        if(s.equals(""))return s;
        Map<Character,List<Integer>> map = new HashMap<>();
        char[] array = s.toCharArray();
        Integer ans = 0;
        String result = "";
        
        for(int i = 0 ; i< array.length; i++){
            char one = array[i];
            if(!map.containsKey(one)){
                List<Integer> list = new ArrayList<Integer>();
                list.add(i);
                map.put(one,list);
            }else{
                List<Integer> list = map.get(one);
                //System.out.println("one:"+one);
                for(int j = 0 ; j< list.size() ; j++){
                    Integer num = list.get(j);
                    //System.out.println("num:"+num);
                    if(palindrome(array,num,i)){
                        if(i - num +1 > ans){
                            ans = i - num +1;
                            result = s.substring(num,i+1);
                        }
                    }
                }
                list.add(i);
            }
        }
        if(result.equals("")){
            return s.substring(0,1);
        }
        return result;
    }
public boolean palindrome(char[] array,int start,int end){
        int i = start;
        int j = end;
        boolean state = true;
        while(i < j){
            if(array[i]!= array[j]){
                state = false;
                //System.out.println(i+":"+j);
                break;
                
            }
            i++;
            j--;
        }
        return state;
    }
}

暴力法，103个测试用例，通过了102个，aaaaaaaaaaaaaaaaaa这个超时

思路2

看参考答案
中心对称法
只有2n-1个中心，aba，abba
从中心扩展

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Solution {
    public String longestPalindrome(String s) {
        if(s.equals(""))return s;
        char[] array = s.toCharArray();
        int start = 0; int end = 0;
        for(int i = 0 ; i< s.length() ; i++){
            int length1 = center(array, i, i);
            int length2 = center(array, i, i+1);
            int length = Math.max(length1,length2);
            if(length > end - start +1){
                start = i - (length - 1) /2;
                end = i + (length /2);
            }
        }
        return s.substring(start,end+1);
    }
    private int center(char[] array , int left ,int right){
        int L = left;int R = right;
        while(L >= 0 && R< array.length && array[L] == array[R]){
            L--;
            R++;
        }
        return R-L - 1;
    }
}

By

第一季
视角从迪奥杀人案谈起，他叔叔后面买通证人，轻松翻案，麦克纳提把贩毒高楼的掌控者越级上报法官，法官给副局长施压成立专案组，专抓艾文。
凶杀组和DEA成立专案组，麦克纳提两头不是人，惹了上级，被警长穿小鞋。
副局只是快速给法官一个交代，开始很敷衍，给的人都是老弱病残，警督开始给人的印象是想往上走，所以比较官僚的，听上面指令打压麦克，但他也在不断争取权益，要到有用的人，和上面抗争增加调查力度和时间。
每个人很立体，面临各种复杂的抉择。
他们开始监听平房区的电话，逐渐了解到了贩毒人员的组成。开始一盘散沙的人员也逐渐有了凝聚力。其中穿插了奥马尔抢劫毒贩的剧情，奥马尔抢劫了迪奥的毒品，艾文大怒，悬赏他们的人头，奥马尔的伙伴和小弟相继被杀，奥马尔怒了，与警方合作，逐渐摸清楚毒贩的组织。先抓住了博德。
其中有很多选择很让人印象深刻，迪奥在平房区看到小弟们下棋，用国际象棋中的棋子比喻他们身边的人，王是艾文，大家都保护他，斯丁格是皇后，处理大小事务。毒品房是车，不断更换位置。他们是小兵，随时可能牺牲，但要是到了底线就能成为王。
在警察的几个小弟喝了酒半夜去高房区闹事，被烧车， 打瞎一个孩子的眼睛，丹尼尔斯面临2中选择，1是承认是自己让他们去的，替下属顶锅，2是让下属承担罪行，撇清自己。 他选择帮下属顶下责任，这个人既想向上爬，又有责任感不放弃下属。
福瑞蒙之前当警察调查一个案子牵扯出一个高管的亲属贩毒，本可以放过，但他还是告了他，得罪了上司，被流放到证物组，他雕微缩家具来打发时间，跟麦克纳提的行为很相似。
人物很有特点，一组是毒贩组，老大艾文，隐秘，多疑拥有很多财产。斯丁格，代理人，处理大小事务。几个打手。这是毒贩高层。迪奥，老大的外甥，开始因为杀人去法庭打官司翻案，看到证人因为自己被杀，心存怜悯，还有一丝的良知，看到吸毒人员拿假钱，自己也没处理，但手下就是一顿毒打，他是这一季的切入点，后面他被分配到平房区管理那里，在平房区还有一些手下。
奥尔马，打劫毒贩，有自己的原则，不杀害无辜者，令毒贩闻风丧胆，但因为打劫艾文，被悬赏，同伴，手下被杀。他与警方合作，复仇。
警察组，凶杀专案科，麦克纳提，酗酒，离婚，与前妻关系不好，但对自己的孩子很好，生活一团糟，但破案能力很强，为了破案，越级上报法官，虽然成事，但自己里外不是人，得罪了很多人。邦克，麦克纳提的答案，破案好手。警长一心仕途，政绩，对下属不关心。
缉毒组，副局长，一心政治。丹尼尔斯也想往上爬，同时对下属很好，主动顶罪。基玛，拉拉女警察，破案能力强。福瑞蒙破案高手，也是刚正不啊，导致被流放到证物组。普兰兹兰斯基，高层的女婿，但经常惹祸，但接触了监听破译，有了突破，让人刮目相看。还有两个想退休的酒鬼警察。

By

题目

反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-linked-list

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
[https://leetcode-cn.com/problems/reverse-linked-list/submissions/]

解题思路

迭代和递归方式

迭代

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode node = head;
        ListNode pre = null;
        if(node == null)return head;
        ListNode next = node.next;
        while(node != null && next!=null){
            node.next = pre;
            pre = node;
            node = next;
            next = node.next;
            
        }
        node.next = pre;
        return node;
    }
}

递归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null)return head;
        return reverse(head,null);
    }
    public ListNode reverse(ListNode node,ListNode exist){
        ListNode next = node.next;
        if(next == null){
            node.next = exist;
            return node;
        }
        node.next = exist;
        return reverse(next,node);
    }
}

官方解法

1
2
3
4
5
6
7
8
9
class Solution {
   public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode p = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return p;
    }
}