leecodecode【二分查找】【2026.5.28打卡-java版本】

在排序数组中查找元素的第一个和最后一个位置

要点：用闭区间的写法，找target的lstart，找target+1的left -1就是end

class Solution {
    public int[] searchRange(int[] nums, int target) {
        //闭区间的写法
        int start = lowerBound(nums, target);
        if(start == nums.length || nums[start] != target){
            return new int[]{-1, -1};
        }

        int end = lowerBound(nums,target+1) -1;
        return new int[]{start, end};

        
    }

    public int lowerBound(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = left +(right -left)/2;
            if(nums[mid] >= target){
                right = mid -1;
            }else{
                left = mid + 1;
            }
        }

        return left;
    }
}

寻找旋转排序数组中的最小值

要点：用开区间写，比nums【mid】和nums【last】

class Solution {
    public int findMin(int[] nums) {
        //开区间
        int left = -1;
        int right = nums.length - 1;
        while(left + 1 < right){
            int mid = left + (right - left)/2;
            if(nums[mid] > nums[nums.length - 1]){
                left = mid;
            }else{
                right = mid;
            }
        }

        return nums[right];
    }
}

方法2：闭区间，找个min来记录，就是利用其中一半肯定是有序的，可以确定有序一方最小的数

class Solution {
    public int findMin(int[] nums) {
        //二分法
        int left = 0;
        int right = nums.length - 1;
        int min = Integer.MAX_VALUE;

        while(left <= right){
            int mid = left + (right - left)/2;
            //注意这个等于号！！！
            if(nums[left] <= nums[mid]){
                min = Math.min(min, nums[left]);
                left = mid+1;
            }else{
                min = Math.min(min, nums[mid]);
                right = mid -1;
            }
        }

        return min;

        
    }
}

寻找峰值

方法1：最大值

class Solution {
    public int findPeakElement(int[] nums) {
        //找最大值
        int max = 0;
        for(int i = 0; i < nums.length; i++){
            if(nums[i] > nums[max]){
                max = i;
            }

        }

        return max;
        
    }
}

方法2：二分法，开区间，因为-1是无限小，另一端是无限大

class Solution {
    public int findPeakElement(int[] nums) {
        //开区间
        //开区间 (left, right) 用于二分探测，但实际候选峰值始终在 (left, right] 内，循环结束时 left+1 == right，此时 right 即为所求峰值。
        int left = -1;
        int right = nums.length - 1;
        while(left + 1 < right){
            int mid = left + (right - left)/2;
            if(nums[mid] > nums[mid +1]){
                right = mid;
            }else{
                left =mid;
            }
        }

        return right;
        
    }
}

搜索旋转排序数组

要点：利用一半已经是有序的性质

class Solution {
    public int search(int[] nums, int target) {
        //闭区间,总有一遍是有序的,判断是否再有序的那边
        int left = 0;
        int right = nums.length -1;
        while(left <= right){
            int mid = left + (right - left)/2;

            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] >= nums[left]){
                if(target < nums[mid] && target >= nums[left]){
                    right = mid -1;
                }else{
                    left = mid+1;
                }
            }else{
                if(target > nums[mid] && target <= nums[right] ){
                    left = mid +1;
                }else{
                    right =mid -1;
                }
            }
        }

        return -1;
        
    }
}

搜索插入位置

要点：闭区间的写法

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length -1;
        while(left <= right){
            int mid = left + (right - left)/2;
            if(nums[mid] == target){
                return mid;
            }else if(target < nums[mid]){
                right = mid -1;
            }else{
                left = mid +1;

            }
            
        }

        return  left;
        
    }
}

开区间写法

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = -1;
        int right = nums.length;
        while(left + 1 < right){
            int mid =left +(right - left)/2;
            if(nums[mid] >= target){
                right = mid;
            }else{
                left = mid;
            }
        }
        
        return right;
    }
}

搜索二维矩阵

要点：开区间，要判断是否相等，可能存在找不到

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int n = matrix.length;
        int m = matrix[0].length -1;
        for(int i = 0; i < n; i++){
            if(target < matrix[i][0]){
                return false;
            }

            if(target > matrix[i][m]){
                continue;
            }

            int left = -1;
            int right = m +1;
            while(left +1 < right){
                int mid = left +(right - left)/2;
                if(matrix[i][mid] >= target){
                    right = mid;
                }else{
                    left = mid;
                }
            }

            if(matrix[i][right] ==  target){
                return true;
            }else{
                break;
            }
        }

        return false;

        
    }


}

闭区间

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int n =matrix[0].length;
        for(int i = 0; i < matrix.length; i++){
            if(target < matrix[i][0]){
                return false;
            }

            if(target > matrix[i][n-1]){
                continue;
            }

            int left = 0;
            int right = n-1;
            //<=！！
            while(left <= right){
                //mid的写法
                int mid = (right - left)/2 + left;
                if(matrix[i][mid] == target){
                    return true;
                }else if(matrix[i][mid] < target){
                    left = mid +1;
                }else{
                    right = mid - 1;
                }
            }
        }

        return false;


    } 
    
}

随机知识

二分查找总结：闭区间 vs 开区间

二分查找的核心在于明确区间的定义，不同的定义决定了循环条件、边界更新和最终答案的位置。

---

一、三种区间定义速览

区间类型	表示	初始边界	循环条件	收缩方式	终止状态	适用场景
闭区间	[left, right]	left=0, right=n-1	while (left <= right)	left = mid+1 right = mid-1	left > right	精确查找某个值（找到即停）
左闭右开	[left, right)	left=0, right=n	while (left < right)	left = mid+1 right = mid	left == right	查找边界（第一个满足条件的位置）
开区间	(left, right)	left=-1, right=n	while (left+1 < right)	left = mid right = mid	left+1 == right	通用，完全避免 ±1 错误

---

二、闭区间 [left, right] 详解

特点：左右边界都在搜索范围内，区间包含两端。

java

int left = 0, right = nums.length - 1;
while (left <= right) {          // 区间非空
    int mid = left + (right - left) / 2;
    if (nums[mid] == target) return mid;
    else if (nums[mid] < target) left = mid + 1;
    else right = mid - 1;
}
return -1;                       // 未找到

关键点：

• 循环条件 <=：因为 left == right 时区间还有一个元素，需要检查。

• 收缩必须 +1 或 -1，否则死循环（mid 已经比较过，需要排除）。

• 结束时 left > right，right 是最后一个 < target 的位置，left 是第一个 > target 的位置。

适用：标准查找（找到即返回）、或需要精确匹配的场景。

---

三、左闭右开 [left, right) 详解

特点 ：左边界包含，右边界不包含。区间长度 = right - left。

java

int left = 0, right = nums.length;   // right 指向末尾的下一个
while (left < right) {               // 区间非空
    int mid = left + (right - left) / 2;
    if (nums[mid] >= target) {
        right = mid;                 // 保留 mid，因为右开
    } else {
        left = mid + 1;
    }
}
return left;                         // 第一个 >= target 的索引

关键点：

• 循环条件 <，因为 left == right 时区间为空。

• 右边界更新为 mid（不包含 mid 但保留它作为候选），左边界更新为 mid+1（排除 mid）。

• 结束时 left == right，就是答案位置（如第一个满足条件的位置）。

适用：查找边界（lower_bound, upper_bound）、二分答案、大多数常规二分问题。

---

四、开区间 (left, right) 详解

特点 ：左右边界都不在搜索范围内，区间内元素为 (left, right) 中的所有整数。

java

int left = -1, right = nums.length;   // 覆盖所有有效索引
while (left + 1 < right) {            // 区间内至少有一个整数
    int mid = left + (right - left) / 2;
    if (条件成立(mid)) {
        right = mid;                  // 答案在左侧
    } else {
        left = mid;                   // 答案在右侧
    }
}
return right;                         // 第一个满足条件的位置

关键点：

• 循环条件 left+1 < right 等价于 left+1 <= right-1，确保区间非空。

• 收缩时都直接赋值为 mid，无需 +1 或 -1，因为 mid 本身不在新区间内（作为新边界）。

• 结束时 left+1 == right，此时 right 是第一个满足条件的位置，left 是最后一个不满足的位置。

• 初始边界要选得足够"宽"，保证答案始终在开区间内或等于 right。

优点 ：完全不用纠结 +1/-1，不会死循环，代码统一。

缺点：初学可能不习惯，但一旦掌握非常稳妥。

适用：所有二分场景（lower_bound, upper_bound, 峰值, 旋转数组最小值等）。

---

五、如何选择？

情况	推荐区间
精确查找目标值，找到立即返回	闭区间 [l, r]（最直观）
查找第一个/最后一个满足条件的位置	左闭右开 [l, r) 或 开区间 (l, r)
需要在旋转数组、山脉数组等复杂条件中二分	开区间 (l, r)（最安全）
希望代码统一、避免边界错误	开区间 (l, r)（强烈推荐）

---

六、常见错误与避坑

错误	后果	正确做法
闭区间用 while (left < right)	当 left==right 时会漏掉最后一个元素	用 while (left <= right)
开区间用 while (left < right)	区间为空时仍可能进入循环（如 left=0,right=1 时 0<1 为真，但开区间 (0,1) 无整数）	用 while (left+1 < right)
闭区间收缩时忘记 +1/-1	死循环	总是 left = mid+1，right = mid-1
左闭右开收缩时左右不对称	边界混乱	统一：right = mid，left = mid+1
开区间收缩时用了 ±1	破坏开区间性质，可能跳过答案	统一：left = mid，right = mid
计算 mid = (l+r)/2	大数组溢出	用 l + (r-l)/2 或 (l+r) >>> 1

---

七、模板总结

闭区间精确查找

java

int l = 0, r = n-1;
while (l <= r) {
    int m = l + (r-l)/2;
    if (nums[m] == target) return m;
    if (nums[m] < target) l = m+1;
    else r = m-1;
}
return -1;

左闭右开查找下界

java

int l = 0, r = n;
while (l < r) {
    int m = l + (r-l)/2;
    if (nums[m] >= target) r = m;
    else l = m+1;
}
return l;

开区间通用模板

java

int l = -1, r = n;
while (l+1 < r) {
    int m = l + (r-l)/2;
    if (check(m)) r = m;
    else l = m;
}
return r;   // 或 l，视 check 的含义而定

---

八、一句话记忆

• 闭区间 ：l<=r，l=m+1, r=m-1，找到就停。

• 左闭右开 ：l<r，l=m+1, r=m，结束 l==r 是答案。

• 开区间 ：l+1<r，l=m, r=m，结束 l+1==r 时 r 是答案。

建议掌握开区间写法，因为它统一、安全、不易错，适合所有二分查找问题。

大型语言模型推理范式：从提示工程到自主智能体------综合技术综述

摘要： 大型语言模型的推理能力是当前人工智能研究的核心前沿。本综述系统梳理了从基础提示工程到自主智能体的技术演进全景。我们首先提出四层范式框架------基础提示工程、结构化推理范式、智能体行动范式与复合智能系统------并深入剖析各范式内部的方法变体与技术演进。在此基础上，我们从统一视角比较了不同范式的适用边界、性能特征与协同机制，并探讨了评估体系、前沿突破与未来发展路径。本综述旨在为研究人员、架构师与开发者提供关于大模型推理技术演进的系统性理解，为技术选型和方向探索提供战略参考。

一、引言

大型语言模型已从"语言模仿者"进化为具备复杂推理能力的认知体。然而，如何有效激发、引导和组织大模型的推理过程，始终是制约其实际应用的核心挑战。这一问题之所以关键，在于大模型推理的底层机制与传统符号推理有着根本差异。

从认知神经科学的角度来看，大模型的生成过程可以被类比为人类的"系统1"思维------快速、直觉、依赖模式匹配。它能够在海量预训练语料的基础上，以极高的流畅度完成语言生成任务，但当面对需要多步逻辑推导、规划或与外部环境交互的任务时，模型内部缺乏显式的符号化推理引擎，难以保障推理的语义稳定性、逻辑一致性和跨任务泛化能力。这正是自2022年以来，学界与工业界持续探索各类"推理范式"的根本驱动力------本质上，这些范式都在尝试为模型提供"系统2"思维的脚手架。

本综述的独特价值在于：第一，我们构建了统一的四层分类框架，将看似分散的技术（提示工程、结构化推理、智能体行动、复合系统）有机串联，揭示其演进的底层逻辑：从"如何让模型思考得更深"，到"如何让模型思考与行动结合"，再到"如何让模型通过协作与进化实现持续提升" ；第二，我们聚焦2025-2026年的前沿进展，涵盖最近发表的综述与突破性成果；第三，我们为每种范式提供了对应开源/商业实现的对照，形成可供参考的技术选型矩阵。

二、分类框架与范式概览

本综述将大模型推理技术演进划分为四个层次，它们之间存在清晰的递进逻辑：

层次	核心问题	代表范式	技术逻辑
第一层：基础提示工程	如何让模型输出更准确？	Zero/Few-shot、CoT	通过示例或指令引导模型行为，不改变模型参数
第二层：结构化推理	如何提升多步推理的准确性与鲁棒性？	ToT、GoT、Self-Consistency	从单一线性思维扩展到多路径并行探索与思维网络
第三层：智能体行动	如何让模型与环境交互并执行工具？	ReAct、ReWOO、Reflexion	将推理与工具执行解耦或交替进行，实现"边想边做"
第四层：复合智能系统	如何整合多组件完成复杂任务？	RAG、多智能体、CodeAct	整合检索、代码执行与多角色协作，实现复合智能

这四个层次并非简单的"替代"关系，而是在实际系统中常共存、互补、叠加使用。其中第二层与第三层的界限尤为重要：第二层（结构化推理）关注模型内部的思维结构，不涉及外部工具调用；第三层（智能体行动）则引入外部交互，其内部思考环节本身就可以复用第二层的结构化推理方法。

三、基础提示工程范式

3.1 零样本与少样本提示

零样本提示不向模型提供任何参考示例，直接通过指令让模型执行任务，本质是对模型预训练和指令微调结果的直接调用。它的局限在于依赖"快思考"模式而非严谨的逻辑推演。少样本提示通过在Prompt中提供若干个输入-输出示例，引导模型理解任务模式------这本质是一种"激活"而非"学习"，示例充当锚点，缩小模型在生成时的概率搜索空间。这两种方法为后续更复杂的推理范式奠定了交互基础。

3.2 思维链（Chain-of-Thought）

CoT的核心是在输出最终答案前，强制模型先生成一系列中间的、连贯的推理步骤，从而将复杂问题拆解为逻辑连贯的子任务。其实现方式极为简洁，即使在零样本场景下，仅需在Prompt中加入一句"Let's think step by step"即可触发CoT效果。

然而，CoT的局限性同样显著：首先，其效果与模型规模正相关，通常在参数量超过100亿的模型上才能展现出明显增益；其次，推理路径是线性的，一旦某个中间步骤出错，后续推理将全盘皆错，无法回溯------这与人类"回头检查"的认知模式形成鲜明对比；最后，CoT本质是纯粹的"内部思考"，依赖模型自身的知识储备，无法调用外部工具获取实时信息。

从技术深度来看，CoT的成功依赖大模型在预训练中习得了丰富的"推理模式"，CoT只是在推理时激活这些模式------若模型预训练数据中缺乏相应的推理模式，CoT也难以发挥效用。

3.3 结构化推理：从CoT到ToT与GoT

思维树（Tree-of-Thoughts, ToT） 将推理从线性链条拓展为分支树状结构。在每个推理节点上，模型生成多个候选思路，通过评估器打分，选择最有前景的分支继续探索，必要时可回溯重新选择。在"24点游戏"这类解空间广阔的任务中，ToT因其能够并行尝试多种数字组合而表现出远超CoT的性能。

思维图（Graph-of-Thoughts, GoT） 进一步突破了树形结构的限制，将推理建模为有向图网络。不同思路节点之间可以建立任意连接------合并、分离、循环引用等复杂关系均被支持。研究发现，GoT相比ToT实现了约62%的质量提升，同时降低了约31%的计算成本。这一数据差异值得关注：GoT的优势在于其图结构允许多条推理路径共享中间节点、合并信息、循环迭代，从而以更少的LLM调用获得更优的推理质量。然而，GoT的工程复杂度显著高于前两者------图结构的构建、节点连接关系确定、分支合并与修剪策略均为未完全解决的工程难题。

从计算成本看，三者的递进关系为：CoT < ToT < GoT，而推理能力同样呈递增趋势。实际部署需在性能与资源约束间进行权衡。

四、智能体行动范式

如果说结构化推理增强的是模型的"思考能力"，那么智能体行动范式则回答了一个更深层的问题：思考之后，模型如何"行动"？

"行动"的意义远不止于调用一个工具。它意味着模型需要实现从"符号运算"到"物理/数字世界因果干预"的认知跨越------模型不再只是被动地预测下一个Token，而是主动在真实或模拟环境中触发状态变更。这种从认知到行动的跃迁，是AI从"聊天机器人"走向"自主智能体"的关键拐点。

4.1 ReAct：连接思考与世界

ReAct首次将大模型的"推理"与"行动"系统性地整合为一个循环，构建"思考-行动-观察"的闭环。在ReAct框架下，每一步思考引导一个行动（如调用搜索引擎、计算器、API），行动的结果作为观察反馈给模型，触发下一轮思考与行动。

这种交替循环使模型能利用外部工具获取实时信息、执行计算和更新知识，有效缓解了CoT模式中模型纯依赖内部知识所导致的事实幻觉问题。但它的缺陷也同样突出：效率低下，每次行动后都需要调用一次LLM进行"观察"和"再思考"，导致Token消耗量和延迟成本显著增加，且对提示词的句法结构高度敏感。

从更深层看，ReAct的"思考"环节在实际实现中往往只是一个简单的CoT步骤，未充分利用结构化推理的高级能力------这为后续将ToT/GoT等结构化推理嵌入ReAct循环指明了优化方向。

4.2 ReWOO：规划与执行解耦

ReWOO（Reasoning Without Observation）的核心创新在于将"规划"与"执行"解耦。它让LLM一次性生成完整的"解决方案蓝图"------包含工具调用依赖关系的执行计划，然后由"工作器"模块并行执行所有工具调用，最后通过"求解器"综合结果。

研究数据显示，ReWOO相比ReAct在HotpotQA等基准测试上可实现约5倍的Token效率提升和约4%的准确率增益。然而，其适用场景有明确限制：在需要根据环境实时反馈进行动态决策的任务（如对话系统、实时导航）中效果不佳，更适合路径可预测的结构化任务。

4.3 自我纠错与反思范式

在智能体行动中，模型的错误往往源于推理失误或行动策略偏差，需要一种让智能体能够"从失败中学习"的机制。从当前的研究趋势来看，自我纠错正从两个方向协同发展：

训练时学习方向（Training-time Learning） ：代表工作包括清华与DeepSeek联合推出的DeepSeek-GRM奖励模型，通过引入"自我批评"机制实现推理性能的持续优化；以及NeurIPS 2025发表的研究提出为模型添加"错题本"，记录犯错时的内部思考状态（包括问题、推理过程和错误位置），通过辅助模型学习这些"错题本"来提升主模型的推理质量。这种方法将反思能力内化到模型参数中，推理时无需额外步骤。

推理时反思方向（Inference-time Reflection） ：代表工作如Reflexion框架，通过"执行-评估-反思"三模块闭环实现类人认知循环。以端到端GUI智能体为例，最新研究已实现了"犯错-反思-修正"的完整闭环，模拟人类认知全过程。斯坦福大学提出的ACE（Agentic Context Engineering）更进一步，让上下文自主进化，通过反复生成、反思并编辑自己的提示，实现"让上下文越变越聪明"------在智能体测试中，ReAct+ACE相比ReAct+ICL和ReAct+GEPA分别领先12.3%和11.9%。

这两种方向的协同正是当前的研究热点：推理时反思提供即时纠错能力，训练时反思将经验沉淀为模型能力，二者结合可实现"边用边学"的持续进化。

五、复合智能系统：超越单一体

真实世界的任务复杂度远超单一模型的能力边界，驱动学界与工业界探索"复合智能系统"这一新兴范式。

从架构视角看，复合智能系统经历了从模块叠加到智能编排的演变。早期的RAG（检索增强生成）是最基础的复合形态------通过将检索器与大模型组合，解决了模型知识僵化问题。此后，HuggingGPT首次将LLM定位为"中央控制器"，负责理解多模态任务并将其分解、调度给Hugging Face社区的专家模型去执行。CodeAct和TaskWeaver等代码驱动框架则允许大模型直接生成并执行Python代码来完成任务，利用编程语言的强逻辑实现了更复杂的行动空间控制。

多智能体系统代表了复合智能的更高形态。当前主流框架的演进可概括为三个代际：

第一代：中心化编排 ------ 以HuggingGPT为代表，LLM作为中央调度器将任务分发给专家模块。这种架构适合任务可穷举、模块边界清晰的场景，但中心节点易成为瓶颈，也难以处理需要多方迭代协商的任务。

第二代：对话式协作 ------ 以AutoGen为代表，通过多智能体对话自然涌现工作流。开发者定义角色后，具体协作流程在智能体间的动态对话中形成，更灵活但也更依赖LLM的协调能力。在长对话场景中对话上下文可能偏离初始目标。

第三代：图式编排 ------ 以LangGraph为代表，通过有向无环图精确定义智能体协作顺序。这种设计哲学强调确定性控制，特别适合金融交易、订单处理等强一致性场景------通过状态持久化机制保障执行的可追溯性。测试数据显示，图式编排可使复杂对话流程开发效率提升2-3倍。此外，CrewAI通过预定义角色模板简化协作任务编排，OpenAI Swarm则将任务分解与并行处理结合，在医疗诊断等场景中可并行调用影像分析、病理推理等多个专业智能体进行协同验证。

六、统一比较与协同分析

6.1 范式维度的统一分析

将前文分散讨论的范式置于统一框架中进行横向比较：

维度	CoT	ToT	GoT	ReAct	ReWOO	多智能体
核心机制	线性推理	树搜索	图推理	推理-行动交替	规划-执行解耦	角色协作
是否调用工具	否	否	否	是	是	是（多体）
计算成本	低	中	高	高	中（高效）	高（协作开销）
错误恢复	❌ 线性易错传	✅ 回溯探索	✅ 节点合并	⚠️ 依赖Observation	⚠️ 静态规划	✅ 协作纠错
适用任务	数学推理	规划类	关系推理	动态交互	结构化任务	复杂协作

值得注意的是，"错误恢复"能力在不同范式间存在本质差异。CoT因线性结构完全无法回溯；ToT通过树搜索实现显式回溯；GoT通过节点合并实现更灵活的纠错；而多智能体系统的纠错则表现为"横向校验"------多个智能体间的信息交叉验证与横向修正，这是在纵向路径之外开辟的全新纠错维度，当某个Agent的判断出现偏差时，其他Agent可通过协作识别并纠正，形成1+1>2的纠错能力。

6.2 范式的演进逻辑

从技术演进的宏观视角看，大模型推理领域正经历从"单一智能"向"复合智能"的根本性转变。这一转变的一条隐形主线是从"过程可见"到"结果可审" ：早期的CoT让模型的思考过程变得可见，但这条线性路径一旦走偏就无法修正，且内部错误难以审计；ReAct将这种可见性从思维拓展到行动，但仍维持线性轨迹；而多智能体系统则引入了"并行化可审"机制------多个Agent的独立执行路径天然提供了校验机会，当路径出现分歧时，系统可以通过投票、仲裁、对比等方式进行横向量化审计，显著提升了最终结果的可信度。当前研究的前沿方向------Meta-of-Thought（MoT）------正试图实现更智能的范式选择，让模型根据任务特征动态选择最合适的推理结构。

6.3 范式边界迁移：从清晰到模糊

随着演进深入，传统范式边界正在发生系统性迁移。最具代表性的是CoT和ReAct边界的交叠------当模型在ReAct的思考（Thought）环节中执行更复杂的多步推导，本质上是在Agent框架内复用了结构化推理能力。同样，Reflection范式在训练时（DeepSeek-GRM）和推理时（Reflexion）两个层面都已有高质量实现，二者边界也在融合。GoT作为独立范式仍处于研究早期，但其图结构思想正在被越来越多人用于优化多智能体协作的通信拓扑。因此，当前的技术实践中，不同范式的"共存、互补、叠加"已成为常态，而非"替代"。

七、评估体系与前沿突破

7.1 主流通用基准

模型推理能力的评估已形成多层次基准体系。国际通行的核心基准包括：MMLU（多任务知识评测）、GSM8K（数学推理）、ARC（科学推理）、GPQA（研究生级科学问题）及BBH（BIG-bench Hard）。中文评测生态则演化出四套各具方法论的主流体系，其中SuperCLUE覆盖Agent、Coding、多模态、推理等六大专项基准，OpenCompass作为"评测中台"聚合70多个数据集，C-Eval侧重知识覆盖度，赢政指数则专注真实沙箱环境下的可验证能力。

从评测技术趋势看，已形成"三浪叠加"格局：其一，传统选择题基准趋于饱和，高分模型间的区分度下降；其二，代码沙箱执行和长文档引用验证成为新基准核心方向；其三，动态生成式和对抗性评测方法兴起，以缓解评测污染问题。

7.2 推理专项基准

针对本文聚焦的推理范式，专用评测基准尤为重要。PlanBench评测长程规划与复杂任务分解能力，BBH包含一系列"超越常规"的多步推理任务，MATH专注数学推理的逐步验证。当前评估的共识是：单一指标难以全面反映模型能力，需要结合多项任务、多轮次和动态交互评估。

7.3 最新前沿进展

推理时计算扩展（Inference-Time Scaling） 正成为提升模型复杂推理能力的关键路径。最新综述系统梳理了这一方向的技术演进，涵盖推理、搜索与RAG三大策略，核心洞察是：推理时的计算预算分配（而非简单的模型规模扩展）可能是优化推理表现的更具性价比的手段。

大规模分解智能体过程 代表了更具前瞻性的探索方向。最新研究通过极端任务分解结合多智能体投票机制，MAKER框架已实现超过一百万LLM步骤零错误运行。这标志着从单纯提升单一模型能力，向编排聚焦于微小任务的智能体集群的重大范式转移------当前模型在超过几百步的连续任务中仍存在性能崩塌问题，必须通过任务细粒度分解和多智能体投票来突破这一瓶颈。

思维缓冲区 （Buffer of Thoughts, BoT）通过元缓冲区存储跨任务提炼的高级思维模板，在推理时检索并实例化，显著提升了复杂任务推理准确率至79.4%。其技术本质是在RAG的"检索知识"之上进一步检索"推理模板"，实现了元推理能力的复用。

Meta-of-Thought（MoT） 试图解决"每个范式在孤立状态下表现出色但都受限于固定结构"的根本局限，动态选择最适合当前任务的推理范式------算术任务用CoT，规划类用ToT，关系查询用GoT，多模态任务用HoT。这标志着推理从"优化模型"转向"选择如何思考"的更高层次。

DeepSeek-R1 等推理模型的发布展示了先进推理能力在数学和编程等领域的前沿应用，也标志着推理范式正从学术研究走向实际生产部署。

八、发展总结与未来趋势

综合全文分析，大模型推理范式正经历三个根本性转变：

从参数规模竞争到认知机制建模。 研究重心已从提升参数量转向对思维结构、反思机制和协作策略的探索------高质量推理模型不再仅靠更大的参数，更依赖更聪明的推理机制设计。

从单一路径到多维并行与网络化思维。 推理结构从CoT的线性链条，经ToT的树状分支，演进为GoT的图网络，使模型具备并行探索与多维关联的推理能力。

从单一体到复合智能与自主进化。 单一模型解决复杂任务的能力趋于瓶颈，而复合系统的整合能力与自主进化能力正成为新的增长极。

面向未来，值得高度关注的若干前沿方向包括：

• 范式融合与动态选择（MoT）：从"固定策略"向"自适应认知"迈进的核心路径。

• 长期任务中的错误控制：如何在跨几百步的连续任务中保持推理可靠性，仍是核心挑战。

• 可扩展与安全的LLM-MAS通信机制：多智能体系统的通信效率、安全性与基准建设亟需系统化突破。

• 推理高效化：如何在不牺牲推理质量的前提下，大幅降低Token消耗和延迟，是工业级部署的现实需求。

• 社会级推理：如何将推理能力从单个体扩展到组织和社会级规模，是复杂系统应用的重要方向。

总结而言，大模型推理范式的发展正站在从"让模型如何思考"向"让系统如何智能地使用思考"过渡的关键节点上。 这一转变将重新定义大模型能力边界------不仅影响学术前沿探索，也将深刻重塑软件开发的范式，使"AI优先"从理念走向可工程化的现实路径。本综述所构建的范式框架与演进逻辑，旨在为后续研究和实践提供系统性参照，帮助研发团队在快速演进的技术版图中做出明智的战略选择。

碎碎念：后续会更新每天学习的八股和算法 题，开始准备秋招的第18天。努力连续更新100天！以后每天就按，秋招项目【java+agent】，科研，必做项目，算法，八股，锻炼身体来总结。

总结：今天效率巨低，还是算法题及时反馈感强，不想学其他的，不行！以后要以程序员为职业，首先就是要热爱代码呀！！！！！加油加油加油

1.算法要系统过一遍【灵神】5/27【早上加晚上】

2.秋招项目，【java】开始实际看业务，2.9/10；【agent】还在学，决定把helloagent看一遍，4/16

3.科研要跑一下，无

4.检测项目也得总结文档，还在分析花了可能1h，

5.训练项目看看先选择好，无

6.背八股，无

7.锻炼身体，无

早睡早起吧

【保持心态，持续努力】