ARTS-03

最新推荐文章于 2025-08-01 14:32:16 发布

Dollhan

最新推荐文章于 2025-08-01 14:32:16 发布

阅读量1k

点赞数 7

CC 4.0 BY-SA版权

文章标签：算法 python

本文链接：https://blog.csdn.net/qqnl2323223/article/details/145615870

什么是ARTS？

算法(Algorithm): 每周至少一道LeetCode算法题，加强编程训练和算法学习
阅读(Review)：阅读并点评至少一篇英文技术文章，提高英文水平
技巧 (Tip)：学习至少一个技术技巧，总结、归纳日常工作中遇到的知识点
分享(Share)：分析一篇有关点和思考的技术文章，建立影响力，输出价值观

算法：

题目描述：

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

 

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]
 

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序
 

进阶：

请你设计时间复杂度为 O(n) 的算法解决本问题

前置知识：

双指针方法：利用两个指针从数组的两端向中间移动，比较元素并决定如何填充结果数组。
绝对值比较：由于输入数组已经按非递减顺序排序，但包含负数，我们需要通过比较绝对值来确定平方后的大小关系。

思路：

初始化指针和结果数组：
- 使用两个指针 left 和 right 分别指向数组的起始和末尾位置。
- 创建一个与原数组长度相同的结果数组 result，用于存储平方后的有序值。
双指针遍历：
- 从结果数组的最后一个位置开始填充（即从右向左）。
- 比较 nums[left] 和 nums[right] 的绝对值，将较大的平方值放入结果数组的当前处理位置，并相应地移动指针。
结束条件：
- 当 left 超过 right 时，说明所有元素都已处理完毕。

关键点：

时间复杂度为 O(n)：每个元素只被处理一次，确保算法高效。
空间复杂度为 O(n)：需要额外的空间来存储结果数组。
双指针策略：通过比较绝对值来决定哪个元素的平方值更大，并将其放置在结果数组的正确位置。

代码：

暴力解：

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)):
            nums[i] *= nums[i]
        nums.sort()
        return nums

# 示例测试
print(Solution.sortedSquares([-4, -1, 0, 3, 10]))  # 输出: [0, 1, 9, 16, 100]
print(Solution.sortedSquares([-7, -3, 2, 3, 11]))  # 输出: [4, 9, 9, 49, 121]

时间复杂度：O(nlog⁡n)O(nlogn)，主要由排序操作决定。
空间复杂度：O(1)O(1)，如果忽略输入数组的空间占用，只使用了常数级别的额外空间。

双指针法：

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        n = len(nums)
        result = [0] * n
        left, right = 0, n - 1
        position = n - 1
        
        while left <= right:
            if abs(nums[left]) > abs(nums[right]):
                result[position] = nums[left] ** 2
                left += 1
            else:
                result[position] = nums[right] ** 2
                right -= 1
            position -= 1
        
        return result

# 示例测试
sol = Solution()
print(sol.sortedSquares([-4, -1, 0, 3, 10]))  # 输出: [0, 1, 9, 16, 100]
print(sol.sortedSquares([-7, -3, 2, 3, 11]))  # 输出: [4, 9, 9, 49, 121]

时间复杂度为 O(n)：每个元素只被处理一次，确保算法高效。
空间复杂度为 O(n)：需要额外的空间来存储结果数组。
双指针策略：通过比较绝对值来决定哪个元素的平方值更大，并将其放置在结果数组的正确位置。

阅读：

[2501.12948] DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning

📰

1. Introduction

背景：近年来，大型语言模型（LLMs）在推理能力方面取得了显著进展，但如何有效提升推理能力仍是一个开放问题。

1.1 Contributions

Post-Training: 通过大规模强化学习（RL）直接应用于基础模型，而不需要监督微调（SFT），从而显著提升推理能力。这种方法允许模型自主探索解决复杂问题的思维链（CoT），开发出DeepSeek-R1-Zero。

Pipeline for DeepSeek-R1: 引入了一个包含两个RL阶段和两个SFT阶段的管道，旨在发现改进的推理模式并符合人类偏好。

Distillation（蒸馏）: 展示了较大的模型可以将推理模式提炼到较小的模型中，使得这些小模型的表现优于通过RL在小模型上发现的推理模式。

1.2 Summary of Evaluation Results

Reasoning Tasks: DeepSeek-R1在多项推理任务上表现出色，如AIME 2024、MATH-500等，性能接近或超过OpenAI-o1系列模型。

Knowledge: 在知识基准测试（如MMLU、MMLU-Pro、GPQA Diamond）中表现优异，明显优于DeepSeek-V3。

Others: 在创意写作、问答、编辑、摘要等任务中也表现出色，尤其在长上下文理解方面显著超越DeepSeek-V3。

2. Approach

2.1 Overview

讨论了如何通过大规模强化学习来显著提高模型的推理能力，即使没有使用监督微调作为冷启动步骤。进一步介绍了如何通过少量冷启动数据来增强性能。

2.2 DeepSeek-R1-Zero: the Base Model based on Reinforcement Learning

Reinforcement Learning Algorithm: 使用Group Relative Policy Optimization (GRPO) 算法来优化策略模型。

GRPO的基础

什么是GRPO？

Group Relative Policy Optimization（群体相对策略优化）是一种专门用于增强大型语言模型（LLMs）推理能力的强化学习算法。与传统的强化学习方法不同，传统方法依赖外部评价者（如批评者模型-Critic model/net）来指导学习，而GRPO通过评估一组回答之间的相对表现来优化模型。这种方法使训练更加高效，使GRPO特别适合需要复杂问题解决和长链思维推理的任务。

传统的强化学习算法（如Proximal Policy Optimization，PPO）在应用于LLMs的推理任务时面临着重大挑战：

1.依赖批评者模型：

PPO需要一个独立的批评者模型来评估每个回答的价值，这使内存和计算需求增加了一倍。

训练批评者模型非常复杂且容易出错，尤其是在需要对主观或细微差别进行评价的任务中。

2. 高昂的计算成本：

强化学习流程通常需要大量计算资源来迭代评估和优化回答。

将这些方法扩展到更大的LLMs会进一步加剧成本。

3. 可扩展性问题：

绝对奖励评估难以应对多样化任务，使得跨推理领域的泛化变得困难。