小黑饱受同辈人的压力，自己也很无所适从的leetcode之旅:1367. 二叉树中的列表

小黑代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSubPath(self, head: Optional[ListNode], root: Optional[TreeNode]) -> bool:
        self.val_list = []
        self.flag = False
        while head:
            self.val_list.append(head.val)
            head = head.next
        #print(self.val_list)
        def dfs(node,path):
            if not node or self.flag:
                return
            path.append(node.val)
            #print(path)
            if len(path) >= len(self.val_list):
                for i in range(len(path)-len(self.val_list)+1):
                    if path[i:i+len(self.val_list)] == self.val_list:
                        self.flag = True
            dfs(node.left,path[:])
            dfs(node.right,path[:])

        dfs(root,[])
        return self.flag

枚举法(python)

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSubPath(self, head: Optional[ListNode], root: Optional[TreeNode]) -> bool:
        if not root:
            return False
        return self.dfs(root,head) or self.isSubPath(head,root.left) or self.isSubPath(head,root.right)

    def dfs(self,node,head):
        # 匹配到头了
        if not head:
            return True
        # 链表还没到头，就没树了
        if not node:
            return False
        # 不相等
        if head.val != node.val:
            return False
        return self.dfs(node.left,head.next) or self.dfs(node.right,head.next)

枚举法(Java)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSubPath(ListNode head, TreeNode root) {
        if(root == null){
            return false;
        }
        return dfs(head,root) || isSubPath(head,root.left) || isSubPath(head,root.right);
    }
    public boolean dfs(ListNode head,TreeNode node){
        if(head == null){
            return true;
        }
        if(node == null || node.val != head.val){
            return false;
        }
        return dfs(head.next,node.left) || dfs(head.next,node.right);
    }
}

小黑尝试学习一下KMP(看毛片)算法

def build_next(patt):
    # 初始化next数组
    next_ = [0]
    # next数组起点
    i = 1
    # 当前匹配的共同前后缀长度
    prefix_len = 0
    while i < len(patt):
        if patt[i] == patt[prefix_len]:
            prefix_len += 1
            i += 1
            next_.append(prefix_len)
        else:
            if prefix_len == 0:
                next_.append(0)
                i += 1
            else:
                prefix_len = next_[prefix_len-1]
    return next_

def kmp_search(string,patt):
    # 生成next数组
    next_ = build_next(patt)
    i = 0
    j = 0
    while i < len(string):
        if string[i] == patt[j]:
            i += 1
            j += 1
        else:
            # 没有共同前后缀
            if j == 0:
                i += 1
            # 找到下一个较小的共同前后缀
            else:
                j = next_[j-1]
        if j == len(patt):
            return i - j
kmp_search('ABABABCAA','ABABC')

链表的KMP算法小黑实在啃不动了，留在不久的将来去啃

小黑生活

看着身边朋友的忙碌，让小黑对未来更加焦虑了

中午在学校吃个炸串

下午咖啡厅来一杯，顺便学学KMP

逼自己继续去跑步，再不想跑也坚持跑，看着熟悉又陌生的地方，以前充满了梦想的地方

跑完饿了吃个烤冷面，给自己多加一个蛋蛋

校园夕阳风光

回家做核酸，做了馆长

晚上喜茶继续研究KMP代码

早上的麦当劳继续琢磨，总算大概想出来了，被送了一个冰激凌

提交了马拉松赞助商报名

继续坐公交车回学校，看着国贸的蓝天，畅想着自己曾经幻想的未来

在学校参加了银行考试

晚上又和师弟们吃了个炒菜

看到了一个人特别像我

睡前又和小老黑和中老黑一起喝了点

突然发现我的本科老师的孩子的语文老师竟然是我的初中班主任

今日焦虑

一会准备继续笔试了，论文实验压力+秋招压力+同辈竞争压力让小黑真的要受不了了，小黑不知道现在应该干什么才算有意义，身边的人该考编的考编，该考公的考公，只剩小黑一个人在迷茫。为什么身边一些人现在让我如此羡慕，只是因为他们考上公了考上编了，拿着不错的工资，被身边人所追捧，而我只能在边上默默地看着。小黑，走一步看一步吧。好好去笔试，然后咖啡厅读英语再跑步，晚上做实验&学git吧!!