学习日记day49 - 技术栈

Day49_1212

专注时间：5H32min

每日任务：1h=二刷2道力扣hot100(如果是hard，只做一道就好 ， 完成情况及时长： 今 )；【学习资源：PyTorch官方文档：https://docs.pytorch.ac.cn/tutorials/beginner/basics/intro.html】1.5h=PyTorch工程实操(完成情况及时长： 10+8+45把第二个pytorch网页的"局部禁用梯度计算"看懂，就去看第一个pytorch网页 )；1h=周志华机器学习(完成情况及时长： 7 )；【按照Claude的路线】1h=手撕机器学习算法（完成情况及时长： ？？ ）；计算机网络45分钟（完成情况及时长： ？？）

学完机器学习，然后是深度学习、搜广推经典模型（也有很多要手撕的，见Claude生成的）。学完PyTorch，之后是Transformer与大模型架构（见Gemini3pro生成的阶段2）。学快一点，学完还要做搜广推的实战项目。准备一个GitHub Repo把所有手撕过的算法整理进去，这会是最好的复习资料。

必须熟记的API、最简洁的GPT实现、带注释的Transformer实现、推荐系统模型库（包含主流模型实现）还有"Let's build GPT"系列学习视频见Claude的第20页。

学习内容：如上

总结与心得：还是要当天登记学习内容及对应学习时长，不然就忘记了，削弱了成就感。看了何学姐的小红书帖子，依旧是非常的努力，激发了自己学习的动力，加油！我不用搞科研，时间会比她多，肯定能做到的。Numpy学完了。.中午15.00玩抖音玩了一个小时啊，下午饭后也玩了抖音，而且晕碳，直接昏睡30分钟。可惜可惜。

《23.合并K个升序链表》：顺序合并与分治合并

python 复制代码

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[Optional[ListNode]]
        :rtype: Optional[ListNode]
        """
        #solution1:既然是有序的，考虑归并排序里面的并。
        #顺序合并的时间复杂度是 O(kn)（k 是链表数，n 是总节点数），虽然能过部分用例，但最优解是「分治归并」（和归并排序的分治逻辑一致，时间 O(n logk)），建议后续优化。
        #顺序合并是「1 和 2 合并→结果和 3 合并→结果和 4 合并...」（时间 O (kn)）；
        #分治合并是「(1 和 2 合并) + (3 和 4 合并) → 再合并这两个结果」（时间 O (n logk)），效率更高。
        if not lists:
            return None
        if len(lists)==1:
            return lists[0]
        def merge(head1,head2):
            dummyhead = ListNode(0)
            res = dummyhead
            p,q = head1,head2
            #无敌了 又忘记移动res指针
            while p and q:
                if p.val <= q.val:
                    res.next = p
                    p = p.next
                else:
                    res.next = q
                    q =q.next
                res = res.next
            if p:
                res.next = p
            else:
                res.next = q
            return dummyhead.next

        res_list = merge(lists[0],lists[1])
        for i in range(len(lists)-2):
            res_list = merge(res_list,lists[i+2])
        return res_list

python 复制代码

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[Optional[ListNode]]
        :rtype: Optional[ListNode]
        """
        #solution1:既然是有序的，考虑归并排序里面的并。
        #顺序合并的时间复杂度是 O(kn)（k 是链表数，n 是总节点数），虽然能过部分用例，但最优解是「分治归并」（和归并排序的分治逻辑一致，时间 O(n logk)），建议后续优化。
        #顺序合并是「1 和 2 合并→结果和 3 合并→结果和 4 合并...」（时间 O (kn)）；
        #分治合并是「(1 和 2 合并) + (3 和 4 合并) → 再合并这两个结果」（时间 O (n logk)），效率更高。
        if not lists:
            return None
        if len(lists)==1:
            return lists[0]
        def merge(head1,head2):
            dummyhead = ListNode(0)
            res = dummyhead
            p,q = head1,head2
            #无敌了 又忘记移动res指针
            while p and q:
                if p.val <= q.val:
                    res.next = p
                    p = p.next
                else:
                    res.next = q
                    q =q.next
                res = res.next
            if p:
                res.next = p
            else:
                res.next = q
            return dummyhead.next

        #新增分治递归函数
        #参数：当前处理的lists区间[left,right]
        def divide_conquer(left,right):
            if left > right :
                return None
            if left == right:
                return lists[left]
            mid = (left+right)//2
            return merge(divide_conquer(left,mid),divide_conquer(mid+1,right))
        return divide_conquer(0,len(lists)-1)