搜广推校招面经二十五

最新推荐文章于 2025-05-04 19:41:26 发布

Y1nhl

最新推荐文章于 2025-05-04 19:41:26 发布

阅读量1.1k

点赞数 21

分类专栏：搜广推面经文章标签： python 推荐算法搜索引擎算法求职招聘

本文链接：https://blog.csdn.net/yin2567588841/article/details/145760312

版权

搜广推面经专栏收录该内容

89 篇文章

订阅专栏

快手搜推

一、从两种数学角度解释l1和l2的（一个是画图，一个是数值角度）

1.1. 图形角度：几何解释

当优化目标函数（比如损失函数）和正则化项相加时，最优解会在约束区域与损失函数等高线的切点处。L1的菱形顶点在坐标轴上，容易导致某些参数为零，从而产生稀疏性；而L2的圆形切点通常不会在坐标轴上，所以参数往往非零但较小。

1.1.1. L1 正则化（Lasso）

在几何意义上，L1 正则化相当于在参数空间中构造一个菱形（diamond shape）约束。
在优化过程中，目标函数的解会在这个菱形的边界上，特别是在菱形的尖角位置，因为这种约束促进了稀疏性，即很多系数会变为零。
这意味着 L1 正则化倾向于“选择”一些特征，而“忽略”其他特征，通常会导致一些特征的系数完全为零。

   L1 约束（菱形）
    / \
   /   \
  /     \
  --------
*图示：L1 正则化的约束域（菱形）*

1.1.2. L2 正则化（Ridge）

L2 正则化相当于在参数空间中构造一个圆形（circle shape）约束。
这种约束促使所有的参数尽可能小，但不会像 L1 那样使某些参数为零。L2 正则化更倾向于将所有参数向零压缩，而不是完全消除它们。
L2 的效果是使参数平滑分布，避免过度拟合，同时不会使某个特征的权重完全消失。

           L2 约束（圆形）
             ****
           *      *
          *        *
           *      *
             ****
*图示：L2 正则化的约束域（圆形）*

1.2. 数值角度：代数解释

1.2.1. L1 正则化

L1 正则化通过对模型的权重进行绝对值惩罚，目标函数变为：
$\text{minimize} \, \left( \text{Loss Function} + \lambda \sum_{i=1}^{n} |w_i| \right)$
其中， $w_i$ 是模型的参数， $\lambda$ 是正则化参数，控制着惩罚的强度。
通过这种方式，L1 正则化鼓励许多 $w_i$ 变为零，从而产生稀疏解。

1.2.2. L2 正则化

L2 正则化通过对模型的权重进行平方惩罚，目标函数变为：
$\text{minimize} \, \left( \text{Loss Function} + \lambda \sum_{i=1}^{n} w_i^2 \right)$
与 L1 不同，L2 正则化并不强迫权重为零，而是使得所有权重尽可能小，但不会完全消失。
L2 正则化的效果是使得模型的权重分布更加平滑，从而避免过拟合。

1.3. 总结

L1 正则化：几何上是一个菱形约束，倾向于产生稀疏解，使得部分特征的系数为零。
L2 正则化：几何上是一个圆形约束，倾向于平滑所有参数，不会使某个特征的系数为零，但会使它们变得尽可能小。
通过这两种正则化方法，我们可以有效地控制模型的复杂度，避免过拟合。

二、快排

2.1. quicksort排序（ $l o g n$ ）

partition方法 -> 选择基准值
quicksort方法 -> 快速排序主函数
topk_split方法 -> 排序一部分

class Solution:
    def partition(self, nums, left, right):
        """划分函数，选择右端元素为基准，返回基准值的正确位置索引"""
        pivot = nums[right] # 将基准值临时保存起来
        i = left - 1        # 指向小于基准的子数组的末尾
        for j in range(left, right):
            if nums[j] <= pivot:
                i += 1 # 小于基准值的数组加一个元素
                nums[i], nums[j] = nums[j], nums[i]  # 将小于基准的元素交换到左侧
        # 基准值换位置
        nums[i+1], nums[right] = nums[right], nums[i+1]
        return i + 1  # 返回基准值的索引
        
    def quicksort(self, nums, left, right):
        """快速排序主函数"""
        if left < right:
            index = self.partition(nums, left, right)  # 获取基准位置
            self.quicksort(nums, left, index-1)        # 递归排序左半部分
            self.quicksort(nums, index+1, right)       # 递归排序右半部分
        return nums
        
def topk_split(nums, k, left, right):
    #寻找到第k个数停止递归，使得nums数组中index左边是前k个小的数，index右边是后面n-k个大的数
    if (left<right):
        index = partition(nums, left, right)
        if index==k:
            return 
        elif index < k:
            topk_split(nums, k, index+1, right)
        else:
            topk_split(nums, k, left, index-1)

能默写这三个方法，就能解决所有的topk问题。

2.1.1. 获得前k小的数

def topk_smalls(nums, k):
    topk_split(nums, k, 0, len(nums)-1)
    return nums[:k]

arr = [1,3,2,3,0,-19]
k = 2
print(topk_smalls(arr, k))
print(arr)

2.1.2. 获得前k大的数

#获得前k大的数 
def topk_larges(nums, k):
    #parttion是按从小到大划分的，如果让index左边为前n-k个小的数，则index右边为前k个大的数
    topk_split(nums, len(nums)-k, 0, len(nums)-1) #把k换成len(nums)-k
    return nums[len(nums)-k:] 
arr = [1,3,-2,3,0,-19]
k = 3
print(topk_larges(arr, k))
print(arr)

2.1.3. 只排序前k个小的数

#获得前k小的数O(n)，进行快排O(klogk)
def topk_sort_left(nums, k):
    topk_split(nums, k, 0, len(nums)-1) 
    topk = nums[:k]
    quicksort(topk, 0, len(topk)-1)
    return topk+nums[k:] #只排序前k个数字

arr = [0,0,1,3,4,5,0,7,6,7]
k = 4
topk_sort_left(arr, k)

2.2. 215. 数组中的第K个最大元素(hot100_堆_中等)

class Solution:
    def partition(self, nums, left, right):
        """划分函数：以nums[right]为基准，返回基准值的正确位置索引"""
        pivot = nums[right]
        i = left - 1  # 指向小于基准的子数组末尾
        for j in range(left, right):
            if nums[j] <= pivot:
                i += 1
                nums[i], nums[j] = nums[j], nums[i]  # 将小元素交换到左侧
        nums[i+1], nums[right] = nums[right], nums[i+1]  # 基准归位
        return i + 1

    def topk_split(self, nums, k, left, right):
        """快速选择算法核心：找到第k小元素的位置后停止递归"""
        if left < right:
            # 注意必须添加 self. 调用类方法
            index = self.partition(nums, left, right)
            if index == k:
                return  # 找到目标位置，终止递归
            elif index < k:
                self.topk_split(nums, k, index+1, right)  # 处理右半部分
            else:
                self.topk_split(nums, k, left, index-1)  # 处理左半部分

    def findKthLargest(self, nums, k):
        """
        查找第k大元素（时间复杂度 O(n)）
        :param nums: 输入数组（会被原地修改）
        :param k: 第k大（从1开始计数）
        :return: 第k大的元素值
        """
        # 转换为找第 len(nums)-k 小的元素（即升序排列后的目标索引）
        target_pos = len(nums) - k
        self.topk_split(nums, target_pos, 0, len(nums)-1)
        return nums[target_pos]