彬子的Blog

Pi Agent loop

2026-08-04T15:47:00.000Z

一、引子：大模型的三种用法

在聊 Agent Loop 之前，我们先退一步，看看”使用大模型”这件事本身有几种模式。这对理解”为什么需要循环”至关重要。

模式 1：直接调用 —— “模型，回答我”

最原始、最直觉的用法。你构建好提示词，调用一次 API，拿到结果，完事。

1	用户输入 → 构建提示词 → 调模型 → 模型输出 → 展示结果

核心工作在于”构建提示词”** 。提示词写得好，结果就好。一次调用，一次输出，没有来回。

适用场景：翻译、摘要、问答、代码补全——凡是”一问一答”能搞定的事。

模式 2：Workflow —— “模型，你先做第一步，我检查一下，再做第二步”

当任务变复杂，你发现一次性很难得到满意结果。于是你把大任务拆成多步，每步调一次模型，步骤之间由 你的代码 控制流转。

1
2
3

用户输入 → [步骤1: 调模型分析] → [你的代码: 提取关键信息]
         → [步骤2: 调模型生成草稿] → [你的代码: 检查质量]
         → [步骤3: 调模型润色] → 最终输出

每一步模型只负责自己的那份工作， 决策权在你手上 ——你知道什么时候该进入下一步，模型只是流水线上的一环。

适用场景：文档生成流水线、代码审查自动化、RAG（检索增强生成）。

模式 3：Agent Loop —— “模型，你自己决定怎么做”

到了 Agent 模式，你把决策权交给了模型。

1
2
3

用户输入 → 调模型 → 模型说"我需要读文件" → 执行读文件 → 模型看结果
         → 模型说"还需要搜索代码" → 执行搜索 → 模型看结果
         → 模型说"我知道了，答案是..." → 输出 → 结束

关键区别： 步骤之间的流转不再由你写死，而是由模型的输出内容来驱动。 你的代码只做两件事：

把用户的输入和工具执行结果喂给模型
如果模型输出的内容里包含了工具调用请求，就执行它；如果没有，就认为任务完成了

至于”该调什么工具”、“该调几次”——这些由模型的输出内容决定。“什么时候该停”——这是 人类定义的规则 ：当模型的一次输出中不再包含工具调用时，我们就认为循环可以结束了。

用一个对比表格，三种模式的区别一目了然：

维度	直接调用	Workflow	Agent Loop
决策者	用户	你的代码	模型
模型调用次数	1 次	N 次（由代码控制）	不确定（由模型控制）
核心工作	写提示词	设计流程	定义工具和循环
模型角色	执行者	流水线环节	自主决策者
典型场景	翻译、摘要	文档流水线、RAG	编程助手、自动化任务

二、Trace、Turn

在深入源码之前，有两个概念必须分清楚。它们经常被混用，但在 Pi 的代码里，每个都有精确的含义。

Trace（一次完整运行）

一个 Trace 是从用户按下回车、到 Agent 彻底停下来、发出 agent_end 事件的 整个过程 。一个 Trace 包含多个 Turn。

一个 Trace（一次 agent_start 到 agent_end）
│
├── Turn 1：调模型 → 模型返回 toolUse（要读文件）→ 执行 read 工具
│
├── Turn 2：带着工具结果再调模型 → 模型返回 toolUse（还要改文件）→ 执行 edit 工具
│
└── Turn 3：带着工具结果再调模型 → 模型返回 stop（改好了，没有工具调用）→ agent_end

Turn（一个轮次）

一个 Turn 的定义非常精确： 一次模型调用 + 这次调用触发的所有工具执行。

每个 Turn 由一对 turn_start 和 turn_end 事件包裹。关键点： 一个 Turn 只有一次模型调用。 模型返回了 toolUse → 执行那批工具 → 发送 turn_end → 这个 Turn 就结束了。把工具结果喂回去再调模型，那是 下一个 Turn 。

看代码就更清楚了。内层循环每一圈的结构（后面会详讲）：

while (hasMoreToolCalls || ...) {
    if (!firstTurn) emit(turn_start);    // ← 新 Turn 开始

    处理 pendingMessages
    streamAssistantResponse()             // ← 一次模型调用
    检查 stopReason
    executeToolCalls()                    // ← 执行这个 Turn 触发的一批工具
    emit(turn_end);                       // ← 这个 Turn 结束

    prepareNextTurn / shouldStopAfterTurn / 检查 steering
}

一圈内层循环 = 一个 Turn = 一次 turn_start → 一次模型调用 → 工具执行 → 一次 turn_end。

如果模型在一个 Turn 中一口气要求了 3 个工具（read + grep + find），那这 3 个工具都在同一个 Turn 里执行——因为它们都是同一次模型调用的产物。但执行完毕后把结果喂回去再调模型的那一刻，就已经进入下一个 Turn 了。

所以 Trace 和 Turn 的关系就是

Trace（一次完整运行）
│  agent_start
│
├── Turn 1
│   │  turn_start
│   ├── 调模型 → toolUse → 执行工具（read + grep）
│   │  turn_end
│   │
├── Turn 2
│   │  turn_start
│   ├── 调模型 → toolUse → 执行工具（edit）
│   │  turn_end
│   │
├── Turn 3
│   │  turn_start
│   ├── 调模型 → stop → 没有工具
│   │  turn_end
│   │
│   agent_end

注意：首轮 Turn 的 turn_start 是在 runAgentLoop() 入口就发出的，然后 runLoop() 内用 firstTurn 标志跳过首圈的 turn_start，避免重复。

Trace 与 Turn 的嵌套结构

配图说明 ：一个 Trace 外壳内嵌 3 个 Turn，每个 Turn 都是”模型调用 + 工具执行”的完整闭环。注意 Turn 3 没有 ToolCall（虚线框），它的 stopReason = stop 触发循环退出。

三、全景：一条消息的旅程，以及循环怎么转

你输入了”帮我读一下 src/main.ts”并按下回车。从这一刻起发生了什么？让我们站在高处看一遍全过程，同时把”循环怎么转起来的”和”循环什么时候停”一并讲清楚。 不必纠结每个细节 ——后面会逐段拆解源码。

途中你会遇到四个反复出现的”实体”：你的输入变成 消息（Message） ；Loop 调用**模型（Model） 来思考；模型要求的操作用 工具（Tool） 完成；每一步通过 事件（Event）**通知外部。驱动这四者反复运转的机制就是本章主角—— Agent Loop 。

流程全景

你按下回车："帮我读一下 src/main.ts"
│
│  ① 你的输入变成一条消息
│
UserMessage { role: "user", content: "帮我读一下 src/main.ts" }
│
│  ② 进入循环（agentLoop 入口）—— agent_start（一个 Trace 开始了）
│
└── runLoop()
    │
    │  ③ 消息转换（AgentMessage → LLM 认识的 Message）
    │
    │  ┌── Turn 1 ──────────────────────────────────────────┐
    │  │  turn_start                                         │
    │  │  ④ 调用 Model（每 Turn 仅一次模型调用）               │
    │  │  streamSimple(model, { systemPrompt, messages })    │
    │  │       ↓ 逐 token 流式返回                            │
    │  │  AssistantMessage {                                  │
    │  │      content: [ ..., ToolCall { name: "read", ... } ],│
    │  │      stopReason: "toolUse"  ← 有工具调用，继续转      │
    │  │  }                                                  │
    │  │  ⑤ 执行 Tool（工具的五步管道，详见第5章）              │
    │  │  ToolResultMessage { content: [{ text: "文件内容" }] }│
    │  │  turn_end                                            │
    │  └─────────────────────────────────────────────────────┘
    │
    │  循环判断：stopReason 是 toolUse → hasMoreToolCalls = true → 继续
    │
    │  ┌── Turn 2 ──────────────────────────────────────────┐
    │  │  turn_start                                         │
    │  │  ⑥ 第二次调用 Model（工具结果已追加到消息列表）         │
    │  │  streamSimple(model, { messages: [..., toolResult] })│
    │  │       ↓ 模型看到文件内容，开始解释                      │
    │  │  AssistantMessage {                                  │
    │  │      content: [ TextContent { text: "这个文件..." } ],│
    │  │      stopReason: "stop"  ← 没有工具调用，准备停        │
    │  │  }                                                  │
    │  │  turn_end                                            │
    │  └─────────────────────────────────────────────────────┘
    │
    │  循环判断：hasMoreToolCalls = false，pendingMessages 为空
    │  → 内层循环退出
    │  → 外层循环检查 followUp → 空 → 外层循环退出
    │
    └── agent_end（一个 Trace 结束，共 2 个 Turn）

循环怎么转：stopReason —— 唯一的信号灯

整个循环的”油门和刹车”集中在 一个字段 上： stopReason 。模型每次返回的 AssistantMessage 里都带着它。

但在此之前，必须澄清一个关键认知： 模型不会说”我要停了”。 模型只是个 token 预测器——给定上下文，猜下一个 token，如此反复。它不”知道”任务做完了没有。 stopReason 这个字段虽然挂在模型的返回值上，但它的值来自 两个不同的地方 ：

模型 API 真正返回的三种：

stopReason	含义
`"toolUse"`	模型输出了工具调用 JSON，API 检测到后返回
`"stop"`	生成自然终止（遇到了结束标记），没有工具调用
`"length"`	token 数达到 maxTokens 上限，被截断

框架的流式层注入的两种 （模型 API 本身不会返回这两种值）：

stopReason	含义	谁注入的
`"error"`	调用过程异常（网络断了、API 报错等）	流式层的 catch 块： `output.stopReason = "error"`
`"aborted"`	用户主动中止（AbortSignal 触发）	流式层的 catch 块： `output.stopReason = "aborted"`

代码证据（ packages/ai/src/ ）：当 streamSimple 内部的 API 调用抛出异常时，catch 块执行 output.stopReason = options?.signal?.aborted ? "aborted" : "error" 。这不是模型说的，是框架替它”兜底”的。

一条规则驱动整个循环

Loop 实际上只看一件事—— 模型输出里有没有工具调用 。这背后是一条 人类定义的工程约定 ：

如果模型一次输出中没有工具调用，就认为本轮不需要更多操作，循环可以停了。

这不是模型的”智能决策”。换个说法： 不是模型在说”我完成了”，而是我们在说”你没要工具，那就当你完成了”。

代码里最精炼的判断就是这个（伪代码示意，实际见 agent-loop.ts:202-216 ）：

// 简化逻辑（实际见 agent-loop.ts:202-216）
const toolCalls = message.content.filter(c => c.type === "toolCall");
hasMoreToolCalls = false;
if (toolCalls.length > 0) {
  const executedToolBatch = await executeToolCalls(...);
  hasMoreToolCalls = !executedToolBatch.terminate;  // 任何一个工具 terminate 则停止
}

注意：实际驱动循环的不是 stopReason === "toolUse" ，而是 toolCalls 数组长度 > 0 && !terminate 。这意味着：即使 stopReason === "length" （被截断），只要 content 里有 toolCall 块，循环仍会执行工具；反之，即使 stopReason === "toolUse" ，如果所有工具结果都设置 terminate: true ，循环也会停。

内层循环的条件是 while (hasMoreToolCalls || pendingMessages.length > 0) ：

模型返回 toolCall 且工具未 terminate → hasMoreToolCalls = true → 继续转 ：执行工具，把结果喂回去再调模型
stopReason === "stop" 或 "length" 且无 toolCall → hasMoreToolCalls = false → 准备停 （看有没有 pendingMessages）
stopReason === "error" 或 "aborted" → 硬停止 ：立即退出整个循环，不检查 followUp

┌──────────────────────────────────┐
     │                                  │
     ▼                                  │
┌─────────┐  toolUse   ┌──────────┐    │
│ 调模型   │ ─────────→ │ 执行工具  │    │
└─────────┘            └──────────┘    │
     │                      │          │
     │ stop / length        │ 结果追加  │
     │                      ▼ 到消息    │
     ▼                 重新调模型 ──────┘
┌─────────┐
│ 准备停   │   ← 不是模型决定的，是我们的规则
└─────────┘

error / aborted → 直接跳出整个循环（硬停止）

为什么不让代码更智能地判断”任务完成没”？ 因为这正是 Agent 和 Workflow 的本质区别。Workflow 里你知道流程有几步，可以用代码判断进度。但 Agent 模式下，你不知道模型要读几个文件、改几处代码——你唯一能稳定依赖的信号就是： 输出里有没有工具调用。 这既是局限，也是优雅——不需要任何”任务完成度”判断逻辑，代码只做最简单的那层判断。

循环的所有退出路径

stopReason 驱动的循环决策流程

配图说明 ：五种 stopReason 分三路处理——toolUse 让循环继续转；stop/length 准备正常停（仍检查 followUp）；error/aborted 硬停止（不检查 followUp）。注意 stopReason 的两个来源：三种来自模型 API，两种是框架流式层注入的兜底。

退出路径	触发条件	原因
正常退出	`stop` / `length` + 无 followUp + 无 pendingMessages	最常见。模型没要工具，也没追加任务
硬停止	`error` / `aborted`	模型调用本身出了问题，继续跑没意义，不检查 followUp
外部钩子停	`shouldStopAfterTurn()` 返回 true	上下文快满了、达到最大 Turn 数等
工具终止	一批工具的执行结果全部 `terminate: true`	所有工具都同意停止（是 `every` 不是 `some` ）

四、源码详解：基础 Loop 与 coding-agent 的叠加设计

给了你概念全景：消息怎么流动、stopReason 怎么驱动循环、什么时候停。但那都是” 是什么 ”。这一节走进代码，回答” 怎么做到的 ”。

在看 Pi 的源码之前，先搞清楚一件事： 最简单的 Agent Loop 其实极其简短。

最简 Loop：所有 Agent 的最小公约数

剥掉所有产品特性，一个能用的 Agent Loop 只需要这些：

// 最简 Agent Loop（伪代码）
async function simpleLoop(messages, model, tools) {
    while (true) {
        // ① 调模型
        const response = await callModel(model, messages, tools);
        messages.push(response);

        // ② 没有工具调用 → 结束
        if (response.stopReason !== "toolUse") {
            return messages;
        }

        // ③ 有工具调用 → 执行，把结果喂回去
        for (const toolCall of response.toolCalls) {
            const result = await executeTool(toolCall);
            messages.push(result);
        }
    }
}

十几行代码。一个 while 循环，调模型、执行工具、再调模型，直到模型不再要求工具。这就是 §三讲的那套逻辑的最小实现—— 任何 Agent 都需要这个内核 。

Pi 的 coding-agent 在此基础上叠加了什么

Pi 的 coding-agent 是一个 交互式编程助手 ——用户在终端里跟它对话，它可能要读好几个文件、改代码、跑测试。这种产品场景比”最简 Loop”多出了真实的需求：

真实需求	叠加的设计	源码位置
用户在 Agent 工作期间又输入了新指令	steering 消息注入：紧急消息可以在 Turn 之间插队	内层循环开头
系统在 Agent 完成后想追加后续任务（如”顺便跑个测试”）	外层 followUp 循环：内层停了但外层可以重启内层	外层 while(true)
不同复杂度的任务想用不同档次的模型	prepareNextTurn 钩子：每个 Turn 结束时可切换模型/上下文	turn_end 之后
上下文窗口快满了需要触发压缩	shouldStopAfterTurn 钩子：外部判断是否该停	prepareNextTurn 之后

关键认知 ：这些叠加设计都是 coding-agent 的 功能选择 ，不是 Agent 的通用法则。如果你做的是一个”一问一答带工具”的简单 Agent，上面这张表全是多余的——你只需要最简 Loop。

但理解 coding-agent 怎么叠加这些设计很有价值——你自己的产品场景很可能也需要类似机制。接下来，我们以 coding-agent 的完整源码为例，逐段走这些设计。跟着那条”帮我读一下 src/main.ts”的消息，走完从入口到结束的整段旅程。

4.1 入口：runAgentLoop() 收到了什么

§三简要展示了流程全景，这里展开看代码细节——同一个过程，更深入的视角。

你按下回车后，调用链是： Agent.prompt() → runPromptMessages() → runAgentLoop() 。停在入口：

// agent-loop.ts:95-118
async function runAgentLoop(
    prompts: AgentMessage[],     // 你的消息
    context: AgentContext,       // 当前对话上下文（快照副本）
    config: AgentLoopConfig,     // 循环配置（模型、钩子、队列回调）
    emit: AgentEventSink,        // 事件发射器
    signal?: AbortSignal,        // 中止信号
    streamFn?: StreamFn,         // 流式函数（可替换）
): Promise<AgentMessage[]>

六个参数中最重要的三个：

prompts — 你的消息已经被包装成了标准格式：

[{
  role: "user",
  content: [{ type: "text", text: "帮我读一下 src/main.ts" }],
  timestamp: 1748000000000
}]

context — 对话上下文快照。注意是副本（ agent.ts:414-420 的 createContextSnapshot() 创建），Loop 运行期间对 context 的修改不会影响 Agent 类的原始状态：

{
  systemPrompt: "You are a helpful coding assistant...",
  messages: [ /* 之前的对话历史 */ ],
  tools: [
    { name: "read", description: "...", parameters: Type.Object({...}), execute: ... },
    { name: "bash", description: "...", parameters: Type.Object({...}), execute: ... },
  ]
}

config — Loop 的行为配置。这里有一组关键钩子（都是函数，不是数据）：

{
  model: Model,                    // 用哪个 LLM
  convertToLlm: Function,          // AgentMessage[] → Message[] 转换
  transformContext?: Function,      // 调 LLM 前的上下文预处理（如压缩）
  getSteeringMessages?: Function,   // 获取"紧急插队"消息
  getFollowUpMessages?: Function,   // 获取"追加任务"消息
  shouldStopAfterTurn?: Function,   // 每轮结束后是否该停
  beforeToolCall?: Function,        // 工具执行前钩子
  afterToolCall?: Function,         // 工具执行后钩子
  toolExecution: "parallel",        // 工具执行模式
}

这些钩子都是函数而非数据——Loop 在运行时调用它们来”拉取”最新状态。这让 Loop 和外部消息来源彻底解耦。

入口函数只做了三步准备：

Step 1: 创建 newMessages 数组
        → 收集本轮 Trace 产生的所有新消息

Step 2: 把 prompts 追加到 context.messages
        → context.messages = [...context.messages, ...prompts]

Step 3: 发初始事件
        → emit("agent_start")    ← Trace 开始
        → emit("turn_start")     ← 首轮 Turn 开始（入口就发，后续 Turn 在内层循环里发）
        → 对每条 prompt：emit("message_start") + emit("message_end")
        → 调用 runLoop()

数据变化：

入口前：
  context.messages = [user1, asst1, toolResult1]    ← 之前的对话
  newMessages = []

入口后：
  context.messages = [user1, asst1, toolResult1, user2]  ← 你的消息被追加
  newMessages = [user2]                                   ← 收集器开始记录

4.2 runLoop() 的骨架：先看内核，再看叠加

现在进入 runLoop() ——整个系统最核心的代码。别被它的长度吓到，我们先看内核，再看叠加。

内核：内层循环

如果只保留最简 Loop 的逻辑， runLoop 长这样：

// 只保留内核的 runLoop（伪代码）
while (hasMoreToolCalls) {
    // 步骤 B：调 LLM
    // 步骤 C：检查 stopReason → error/aborted 就退出
    // 步骤 D：执行工具
    // 步骤 E：emit turn_end
}
// 结束 → emit agent_end

这就是最简 Loop——调模型、执行工具、turn_end，循环往复。内层循环的退出条件 hasMoreToolCalls 由 toolCalls 数组长度 > 0 && !terminate 驱动（§三讲过）。 这段是所有 Agent 都需要的内核。

叠加：coding-agent 加了两层外壳

但 coding-agent 作为交互式编程助手，需要在内核外面加两样东西：

叠加 1：steering 消息注入 （内层循环开头 + 每圈结尾各检查一次）。用户在 Agent 工作时输入了新指令——这些消息不能等当前任务跑完，得在下一圈开头紧急注入。所以内层循环条件多了一个 || pendingMessages.length > 0 。

叠加 2：外层 followUp 循环 （包在整个内层循环外面）。Agent 自然停了之后，系统可能还想追加任务（比如”顺便跑个测试”）。外层循环让这些追加任务在 同一个 Trace 内 继续跑，不需要重新启动一个新的 Loop。

把内核和两层叠加拼起来，才是完整的 runLoop 骨架：

async function runLoop(currentContext, newMessages, config, signal, emit, streamFn) {

    // ① 首次 steering 检查（在进入内层循环之前！）
    let pendingMessages = (await config.getSteeringMessages?.()) || [];

    // ========== 叠加2：外层循环（followUp 续命）==========
    while (true) {
        let hasMoreToolCalls = true;
        let firstTurn = true;  // 首轮跳过 turn_start（入口已发）

        // ========== 内核 + 叠加1：内层循环 ==========
        while (hasMoreToolCalls || pendingMessages.length > 0) {
            //                                    ↑ 叠加1：steering 消息也驱动循环

            if (!firstTurn) {
                emit({ type: "turn_start" });
            }
            firstTurn = false;

            // 步骤 A：注入 pendingMessages（steering 消息）← 叠加1
            // 步骤 B：调 LLM → streamAssistantResponse()  ← 内核
            // 步骤 C：检查 stopReason                      ← 内核
            // 步骤 D：执行工具                              ← 内核
            // 步骤 E：emit turn_end                         ← 内核
            // 步骤 F：prepareNextTurn → shouldStopAfterTurn ← 叠加（钩子）
            //         → 再次检查 steering                    ← 叠加1
        }

        // ========== 内层循环结束 ==========
        // 叠加2：检查 followUp 队列
        const followUpMessages = (await config.getFollowUpMessages?.()) || [];
        if (followUpMessages.length > 0) {
            pendingMessages = followUpMessages;
            continue;  // 回到外层循环顶部，内层循环重开
        }

        break;  // 两个队列都空，真正退出
    }
}

现在我们逐步骤展开。每个步骤会标注”内核”还是”叠加”，方便你区分。

4.3 【叠加1 · 步骤A】steering 消息注入

什么是 steering？ 这是 coding-agent 的一个交互功能。想象你让 Agent 帮你修一个 bug，Agent 正在读文件、分析代码。这时候你突然想到一个补充：“也检查一下测试文件”——你希望这条指令能插队，而不是等 Agent 把当前任务做完再说。

steering 就是这个”插队”机制。用户在 Agent 工作期间输入的新指令，会被放进 steering 队列。每圈内层循环开头，Loop 先检查这个队列，把紧急消息注入到当前对话中：

if (pendingMessages.length > 0) {
    for (const message of pendingMessages) {
        await emit({ type: "message_start", message });
        await emit({ type: "message_end", message });
        currentContext.messages.push(message);
        newMessages.push(message);
    }
    pendingMessages = [];  // 消费完毕，清空
}

这段代码就是把紧急消息逐条注入到上下文和消息收集器中。

pendingMessages 的第一个来源是 runLoop 一进来就执行的首次 steering 检查（ agent-loop.ts:167 ）。为什么要在进入循环之前就检查？因为用户在等待 LLM 首次响应时可能又输入了内容——这时候消息已经从外部排队了，但循环还没开始，如果不提前取出来，这批消息就漏掉了。

4.4 【内核 · 步骤B】streamAssistantResponse() — 调 LLM

这是整个 Loop 最重的一步——把消息发给模型、拿回流式响应。分为四个阶段。

阶段 A：上下文预处理（可选）

let messages = context.messages;
if (config.transformContext) {
    messages = await config.transformContext(messages, signal);
}

如果配置了 transformContext （如压缩算法），在此预处理消息。不配置就跳过。

阶段 B：AgentMessage → Message 转换（两层消息的边界）

1	const llmMessages = await config.convertToLlm(messages);

这一行站在 Agent 内核和 LLM 的边界上。要理解它为什么存在，得先知道”两层消息”的设计。

Agent 内部维护对话历史时，需要记录的不只是”用户说了什么、AI 回了什么”——它还需要记录 自己的内部状态 。比如 coding-agent 会记录：上下文被压缩过（ CompactionSummaryMessage ）、Bash 命令的执行详情（ BashExecutionMessage ）、分支切换的记录（ BranchSummaryMessage ）。这些是 Agent 自己用的”内部语言”， LLM 根本不认识这些消息类型 ——它只认三种标准消息： UserMessage 、 AssistantMessage 、 ToolResultMessage 。

convertToLlm 就是站在这个边界上的 翻译官 ：把 Agent 的内部语言翻译成 LLM 能理解的协议。默认实现就是一个 .filter() ——只保留三种标准消息：

function defaultConvertToLlm(messages: AgentMessage[]): Message[] {
    return messages.filter(
        (message) => message.role === "user"
                  || message.role === "assistant"
                  || message.role === "toolResult",
    );
}

数据变换：

转换前（AgentMessage[]）：
[
  { role: "user", content: "帮我读一下 src/main.ts", ... },    ← 保留
  { role: "assistant", content: [...], ... },                   ← 保留
  { role: "compactionSummary", summary: "之前的对话摘要..." },   ← 过滤掉
  { role: "toolResult", content: [...], ... },                  ← 保留
]

转换后（Message[]）：
[
  { role: "user", content: "帮我读一下 src/main.ts", ... },
  { role: "assistant", content: [...], ... },
  { role: "toolResult", content: [...], ... },
]

两层消息的完整设计，详见《第6章：消息系统》。

阶段 C：构建 Context 并调用模型

const llmContext: Context = {
    systemPrompt: context.systemPrompt,
    messages: llmMessages,
    tools: context.tools,
};

const streamFunction = streamFn || streamSimple;
const resolvedApiKey =
    (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined)
    || config.apiKey;

const response = await streamFunction(config.model, llmContext, {
    ...config,
    apiKey: resolvedApiKey,
    signal,
});

构建 Context 是这一步的主线。 注意 llmContext 是一个 全新对象 ，每圈内层循环都重建一次。它由三部分组成：

systemPrompt —— 直接复用 Agent 上下文里的系统提示词，告诉模型”你是谁、该遵守什么规则”
messages —— 就是上一步 convertToLlm 过滤后的 llmMessages ，只含 LLM 认识的三种标准消息
tools —— 工具列表（带 schema 定义），让模型知道”这次有哪些工具可以调”

注意一个细节： llmContext.tools = context.tools 是 引用赋值 ——每圈虽然包了个新的 wrapper 对象，但 tools 数组本身是同一份引用，内容字节级稳定。 systemPrompt 同理。只有 messages 真的在长（每圈追加新的 ToolResultMessage）。

那为什么还要每圈重建 llmContext 这个 wrapper？因为有的 Turn 确实会改这三者里的某一个： prepareNextTurn 钩子（§4.7）可能换过模型或改过 systemPrompt，扩展系统（§5）可能动态注册新工具。重建 wrapper 的成本可以忽略（一个 JS 对象），但能保证不会因为共享引用导致难以追踪的状态污染。

这会不会破坏 prompt cache？ 不会。Anthropic 的 prompt cache 是 内容寻址 的——它看的是发过去的字节，不是请求的 identity。每次发的是新对象还是旧对象无所谓，只要 system + tools 的字节不变，cache 就命中。Pi 在 anthropic-messages.ts 里显式在 三个位置 打 cache_control: { type: "ephemeral" } 标记：

位置	源码行	作用
System prompt 末尾	L922/929/938	系统提示词整体作为可缓存前缀
最后一个 tool	L1208	整个 tools 列表作为可缓存前缀
最后一条 user message	L1157-1178	rolling cache ——每 Turn 把 cache 推进到最新消息

第三条尤其精妙：cache breakpoint 不是固定在第一条消息上，而是 跟着最新 user message 走 。这样旧前缀继续命中、新追加的内容被写入，整个对话历史都享受 cache 收益。命中链路大致是：

1
2
3

Turn 1: 写入 [system + tools] → 写入 [messages §1]
Turn 2: 命中 [system + tools] → 命中 [messages §1] → 写入 [messages §2]
Turn 3: 命中 [system + tools] → 命中 [messages §1+§2] → 写入 [messages §3]

还有个容易误解的点： tools 不是被塞到 messages 末尾 。Anthropic API 协议里 tools 是独立的顶层字段（位置在 messages 之前），这个协议设计本身就考虑了 cache——稳定的 tools 在前、变动的 messages 在后，prefix 越长越省。

OpenAI 体系走的是另一条路（ openai-completions.ts:554 ）： prompt_cache_key: sessionId ，OpenAI 后端按 session 自动匹配前缀。DeepSeek、Qwen 等通过 cacheControlFormat: "anthropic" 兼容字段，也能复用 Anthropic 风格的 cache_control 标记（ L593 的 applyAnthropicCacheControl ）。

阶段 D：流式处理响应 —— 原地替换的妙用

streamFunction 返回的是 AssistantMessageEventStream ——一个异步迭代器。这步有一个很精巧的设计：

for await (const event of response) {
    switch (event.type) {
        case "start":
            // 拿到一个"空壳"消息，直接 push 到 context
            partialMessage = event.partial;
            context.messages.push(partialMessage);
            emit({ type: "message_start", ... });
            break;

        case "text_delta":       // 文本增量
        case "toolcall_delta":   // 工具调用增量
        case "thinking_delta":   // 思考增量
            partialMessage = event.partial;            // 更新后的部分消息
            context.messages[last] = partialMessage;    // ★ 原地替换！
            emit({ type: "message_update", ... });      // UI 收到增量更新
            break;

        case "done":
        case "error":
            finalMessage = await response.result();
            context.messages[last] = finalMessage;       // ★ 用最终完整消息替换
            emit({ type: "message_end", ... });
            return finalMessage;
    }
}

为什么要先 push 空壳再原地替换？注意”原地替换”的意思——不是往 context.messages 数组里 push 新条目，而是 用新内容覆盖最后一条 （ context.messages[last] = partialMessage ）。这样 context 的消息数量不变，但最后一条消息的内容在”长大”。

为了 UI 能实时展示 。如果等全部响应完成才 push 到 context，用户在 LLM 思考的几秒里盯着空白屏幕。通过”先放空壳、逐 token 替换”，UI 通过 message_update 事件拿到最新部分消息，能做到逐字渲染。

流式响应原地替换的时间线

配图说明 ：四个时间点的 context.messages[last] 演变——start 时空壳、text_delta 时文字在长、toolcall_delta 时工具调用出现、done 时最终完整消息替换。每一步同步展示 UI 显示状态。

数据在流式响应期间， context.messages[last] 的演变：

start    → { role: "assistant", content: [] }                    ← 空壳 push
text_delta → { content: [{ type:"text", text:"好的..." }] }       ← 文字在长
toolcall   → { content: [{ text:"好的..." },                        ← 工具调用出现
                         { type:"toolCall", name:"read", arguments:{file_path:"src/main.ts"} }] }
done     → { content: [...], stopReason:"toolUse", usage:{...} } ← 最终完整消息替换

4.5 【内核 · 步骤C】检查 stopReason

§三详细讲了 stopReason 的来源和含义。这里看代码怎么处理它。拿到 AssistantMessage 后，立即做一次硬停止判断：

// agent-loop.ts:196-200
if (message.stopReason === "error" || message.stopReason === "aborted") {
    await emit({ type: "turn_end", message, toolResults: [] });
    await emit({ type: "agent_end", messages: newMessages });
    return;   // ← 直接退出整个 runLoop，不检查 followUp
}

error 和 aborted 是”硬停止”——立即发 turn_end + agent_end，直接 return。连工具都不执行，连 followUp 都不检查。这是一种 快速失败 （fail fast）策略：既然模型调用本身就失败了（网络异常或用户中止），继续跑没有任何意义。

而 stop 、 toolUse 、 length 这三种，代码继续往下走——进入工具执行逻辑。区别在于： stop 和 length 时， toolCalls 数组为空，所以工具执行步骤什么也不干。

4.6 【内核 · 步骤D】executeToolCalls() — 执行工具

模型返回的 AssistantMessage.content 里，可能有多个 type === "toolCall" 的块（模型一口气要求了多个操作）。先过滤出来：

1	const toolCalls = message.content.filter((c) => c.type === "toolCall");

然后决定这批工具 并行还是串行 执行：

if (config.toolExecution === "sequential" || hasSequentialToolCall) {
    return executeToolCallsSequential(...);   // 串行
}
return executeToolCallsParallel(...);         // 并行

“一票否决”策略 ：只要这批工具中有 任何一个 声明了 executionMode: "sequential" ，整批都串行。为什么这么保守？因为判断”哪些工具会冲突”很难——edit 和 edit 操作不同文件就安全吗？万一它们编辑的文件有依赖关系呢？所以 Pi 选择了”宁可多等，不可出错”。而 edit 工具内部还有第二道防线（ withFileMutationQueue ，对同一文件的编辑串行化），确保即使外层判断为并行，也不会互相覆盖。

两种执行模式的内部结构：

串行模式：
  ToolCall A: 准备 → 验证 → beforeHook → 执行 → afterHook → emit end
  ToolCall B: 准备 → 验证 → beforeHook → 执行 → afterHook → emit end
  （一个完全结束，才开始下一个）

并行模式（三阶段设计）：
  阶段1 - 准备（顺序）：  A 准备 → B 准备 → C 准备
      ↑ prepareToolCall 含验证和 beforeHook，必须顺序执行
  阶段2 - 执行（并行）：  A、B、C 同时执行（Promise.all）
      ↑ 只有 tool.execute 并行，省时间
  阶段3 - 事件（有序）：  end 按完成顺序发；result 按调用顺序发
      ↑ result 消息保持和 ToolCall 一致的顺序，LLM 收到的上下文才是正确的

注意并行模式的精妙之处： 准备阶段始终顺序 （因为验证和权限检查不能并行——万一 B 被拦截了，C 就不应该执行）， 只有实际执行并行 。

每个工具的结果被包装成 ToolResultMessage ，追加到 context 和 newMessages ：

工具执行后：
  context.messages = [..., user2, assistantMessage, {
    role: "toolResult", toolCallId: "toolu_01", toolName: "read",
    content: [{ text: "文件内容..." }], isError: false
  }]

terminate 机制 ：工具可以在返回结果中设置 terminate: true ，表示”我觉得不该继续了”。但 Loop 不会因为某一个工具喊停就停——它用的是 every 而非 some ： 必须这批工具的全部结果都设置了 terminate 才真正退出 。这是保守策略：只要有一个工具还在正常工作，Loop 就不中断。

工具执行的完整五步管道（prepareArguments → Schema 验证 → beforeToolCall → execute → afterToolCall）详见《第5章：工具系统》。

4.7 【内核+叠加 · 步骤E~F】turn_end + 钩子 + 再次检查 steering

Turn 的核心工作做完了（调模型 + 执行工具），接下来是收尾。收尾分四步，其中前两步是内核，后两步是 coding-agent 叠加的扩展点：

// ① emit turn_end —— 通知外部"这一轮结束了"（内核）
await emit({ type: "turn_end", message, toolResults });

// ② prepareNextTurn —— 给外部一个机会"改装"下一轮（叠加）
// 返回值可包含 context / model / thinkingLevel 三者之一的覆盖
const nextTurnSnapshot = await config.prepareNextTurn?.({...});
if (nextTurnSnapshot) {
    currentContext = nextTurnSnapshot.context ?? currentContext;
    config.model = nextTurnSnapshot.model ?? config.model;
    // thinkingLevel 也在此处覆盖（详见 agent-loop.ts 中 prepareNextTurn 处理逻辑）
}

// ③ shouldStopAfterTurn —— 外部判断是否该停了（叠加）
if (await config.shouldStopAfterTurn?.({...})) {
    await emit({ type: "agent_end", messages: newMessages });
    return;
}

// ④ 再次检查 steering —— 有没有新的紧急消息？（叠加1）
pendingMessages = (await config.getSteeringMessages?.()) || [];

prepareNextTurn —— 这是个容易被忽略但很强大的扩展点。它在每个 turn_end 之后、下一轮开始前被调用，允许外部 动态切换下一轮的配置 。具体例子：

场景：按任务复杂度切换模型

Turn 1: 用户问了一个简单问题 → 模型用 Haiku（快、便宜）
        turn_end → prepareNextTurn 检查到问题很简单
        → 返回 { model: haiku } → 下一轮继续用 Haiku

场景：中途发现任务变复杂了

Turn 1: 用户让"重构这个模块" → Haiku 开始读文件
        turn_end → prepareNextTurn 发现要改的文件很多
        → 返回 { model: opus } → 下一轮自动切到 Opus（强、贵）

除了换模型，它还能换 context （比如注入新的上下文信息）和 thinkingLevel （思考强度）。返回 undefined 表示”什么都不换，按原配置继续”。

shouldStopAfterTurn —— 外部注入的停止判断。coding-agent 层会用它来检查上下文窗口是否快满了（快满了就停下来触发压缩），或者是否达到了最大 Turn 数限制。这是产品层的”安全阀”，最简 Loop 不需要它。

④再次检查 steering —— 一圈内层循环结束，再看看 steering 队列有没有新积攒的紧急消息。如果有，下一圈继续跑。

4.8 回到循环顶部

工具执行完且收尾结束，代码回到内层 while 循环的条件判断。§三已经详细讲了 hasMoreToolCalls 由 toolCalls 数组长度 > 0 && !terminate 驱动——这里只看代码：

1	while (hasMoreToolCalls \|\| pendingMessages.length > 0)

两个条件任一为 true 就继续。 hasMoreToolCalls 由模型输出里有没有 toolCall 块（且未全部 terminate）决定（内核）， pendingMessages 由 steering 队列决定（叠加1）。两个都为 false 时，内层循环退出。

4.9 【叠加2 · 步骤G】外层循环：followUp 的续命机制

内层循环退出了——没有工具要执行，也没有紧急消息。但 coding-agent 的设计是：此时检查一下 getFollowUpMessages() ，看看系统有没有追加任务：

const followUpMessages = (await config.getFollowUpMessages?.()) || [];
if (followUpMessages.length > 0) {
    pendingMessages = followUpMessages;   // 塞进 pending，触发新 Turn
    continue;                              // 回到外层循环顶部
}
break;  // 两个队列都空了，真正退出

如果有 followUp 消息，它们被塞进 pendingMessages ， continue 回到外层循环顶部，内层循环检测到 pendingMessages 不为空， 在同一个 Trace 内 继续跑。这比重新启动一个新的 runAgentLoop() 好在哪？——连续性：同一个 newMessages 数组、同一个事件序列，不需要额外合并。

§四开头已经说过：如果你做的是简单 Agent，外层循环是多余的——内层循环退出后直接 break + emit agent_end 就行了。

4.10 steering vs followUp：一张表看清两种干预

本章出现了两种”外部消息注入”机制。虽然 §四开头已经分别介绍过，但放在一起对比更能看清它们的差异：

维度	steering（叠加1）	followUp（叠加2）
检查时机	runLoop 开始前 + 内层循环每圈结尾	内层循环全部结束后
语义	”紧急插队”——在工具执行间隙中插入	”排队等叫号”——等当前任务全部完成
典型场景	用户在 Agent 工作时输入了新指令	系统在 Agent 完成后追加”顺便跑个测试”

生活类比：steering 是你正在开会，有人敲门递了张纸条——“紧急，先看这个”。followUp 是开完会翻了翻信箱——“不急，但需要处理”。

steering vs followUp 对比

配图说明 ：左红右绿对照——steering 在每圈内层循环开头+结尾检查、紧急插队；followUp 在内层循环全部结束后检查、续命重启。底部列出各自时机/来源/影响/典型场景。

五、总结：Loop 的四条核心设计

回顾从按下回车到 Agent 完成的整段旅程：

1. ReAct 循环模式

Loop 的本质是 Reason（模型思考）→ Act（执行工具）→ Observe（观察结果）→ Reason（再次思考）的循环。模型的输出内容决定”该调什么工具”——这是 Agent 区别于 Workflow 的核心。但”什么时候停”不是模型的决策，而是我们人类定义的规则： 模型不再输出工具调用时，就认为本轮结束。

2. stopReason 驱动机制

整个循环由一个字段驱动： stopReason 。但实际驱动循环的不是 stopReason 本身，而是模型输出里有没有 toolCall 块且未全部 terminate—— "有 toolCall" = 继续转；没有 toolCall 或全部 terminate = 准备停（或立即停）。 “是否继续”不靠代码的复杂判断，只靠一条简单规则：模型的输出中有没有工具调用。 这是 Agent 架构的核心设计原则——把决策外包给模型输出模式，代码只做最简单的信号判断。

3. 内核 + 叠加的架构思路

Agent Loop 的内核极其简短——十几行代码就能实现一个能用的循环。Pi 的 coding-agent 在内核上叠加了 steering（紧急插队）、followUp（任务追加）、prepareNextTurn（动态切模型）、shouldStopAfterTurn（安全阀）等设计。 内核是所有 Agent 的通用法则，叠加是产品功能的按需选择。 做自己的 Agent 时，先搭内核，再按场景加叠加。

Agent Loop 内核与叠加设计

配图说明 ：从里到外的四层洋葱——最内核是最简 Loop（~10 行通用法则）；外层依次叠加 steering（紧急插队）、followUp（任务追加）、钩子（切模型/安全阀）。剥掉任何一层，里层仍能运行。

Pi Agent 上下文工程，模型每一轮到底看到了什么

2026-08-02T04:00:00.000Z

Pi Agent 给人的一个错觉是，它好像记得整个项目。

你让它读文件、跑测试、修改实现，再回头问它为什么这样改，它通常还能接上前面的工作。但打开源码会发现，Pi 并没有给模型一块无限记忆。每次调用模型之前，它都会从会话、工具结果、项目规则和当前输入里，重新裁出一份可以发送的消息。

所以真正值得研究的问题不是模型能记住多少，而是这一轮请求发出之前，Pi 决定让模型看到什么，又把什么留在了上下文之外。

这就是上下文工程。

上图可以先当作全文地图。工具结果要控制体积，项目规则要按层级注入，过长的线性历史要压缩，会话树切换分支时还要保留旧分支的探索成果。它们共同处理的不是同一个问题，也不应该被塞进一个巨大的 summarizeHistory 函数里。

一、先把“上下文”拆成两次变换

在 @earendil-works/pi-agent-core 中，Agent 内部先处理自己的 AgentMessage[]，然后才把它转换成模型 API 能理解的消息。

AgentMessage[]
    ↓ transformContext()
AgentMessage[]
    ↓ convertToLlm()
LLM Message[]
    ↓
模型 API

transformContext 是一个可选的上下文变换点，可以裁剪消息，也可以在调用模型前注入额外信息。
convertToLlm 则负责把 Agent 内部的消息转换成模型协议。

Pi 的 Agent 内部可以保存自定义消息，但模型通常只直接理解 user、assistant 和 toolResult 这类标准消息，因此转换层还要过滤或改写模型不认识的内容。

coding-agent 在这条核心链路之上继续加入系统提示词、工具定义、项目上下文文件、Skills、Session Tree 和工具执行结果。完整一点可以写成这样。

Session Tree + 当前输入 + system prompt + tools
                         ↓
                   AgentMessage[]
                         ↓
                 transformContext()
                         ↓
                   convertToLlm()
                         ↓
                    LLM Message[]

这带来一个很重要的判断。

模型每次看到的上下文，不等于 Session 里保存的所有消息，也不等于终端里显示的全部内容。它是一个在请求前生成的投影。后面讲工具截断和 Compaction 时，都应该记住这个边界。

二、单次工具结果，先在入口处设上限

上下文变长有两个来源。一个是历史越积越多，另一个是某一次工具调用就返回了过大的结果。

限制	默认值	作用
最大行数	2000 行	防止输出行数过多
最大字节数	50KB	防止少量超长行占满窗口
grep 单行长度	500 字符	防止压缩文件的一行命中吃掉大量 token

只限制行数不够，因为压缩后的 JavaScript 可能一行就有几十 KB。只限制字节数也不理想，因为源代码应该尽量按完整行保留，直接在任意字节处切开，结果会变得很难读。因此 PI 采用双重限制，行数或字节数任意一个先到，就停止继续保留。

read 和 bash 为什么从不同方向截断

Pi 并不是所有输出都使用同一种截断策略。

read 读取文件时，开头的 import、类型定义和类接口通常更有助于理解文件结构，因此更适合使用 truncateHead，保留文件开头。

bash 执行命令时，编译错误、测试失败和最终统计往往出现在末尾，因此更适合使用 truncateTail，保留末尾一段。

把尾部截断的核心逻辑压缩成伪代码，大概是这样。

function truncateTail(
  content: string,
  maxLines = 2000,
  maxBytes = 50 * 1024,
) {
  const lines = content.split("\n");
  const kept: string[] = [];
  let bytes = 0;

  for (let index = lines.length - 1; index >= 0; index -= 1) {
    const line = lines[index];
    const lineBytes = byteLength(line) + 1;

    if (kept.length >= maxLines || bytes + lineBytes > maxBytes) {
      break;
    }

    kept.unshift(line);
    bytes += lineBytes;
  }

  return kept.join("\n");
}

这里还有几个工程细节。

UTF-8 字符不能按任意字节切开，中文和 emoji 都要保持完整。
一行本身超过 50KB 时，不能因为它太长就返回空结果，需要保留可读的部分并标记为部分截断。
截断不能是静默丢弃，结果里应当告诉模型原始输出有多大、当前展示了哪一段，以及完整内容是否落在临时文件中。

关键在于，默认只发送高信号片段，同时给模型一条继续获取完整内容的路径，远比让模型在一开始就吞下整份日志稳妥。

两个“2000”不是一回事

truncate.ts 里的 2000 是正常工具结果的最大行数。

Compaction 使用 serializeConversation 准备摘要请求时，又会把每个 toolResult 限制在 2000 个字符左右，并在文本里留下被截断的标记。

前者控制工具结果如何进入普通 Agent Loop，后者控制历史如何进入摘要模型。它们都叫 2000，却处于两条不同的链路上。做上下文预算时，不能只看到一个数字就认为全局已经有了统一限制。

三、系统提示词不是一段固定字符串

工具输出截断是在做减法，系统提示词组装则是在做有选择的加法。

Agent 需要知道项目规范，但不应该每轮都把整个项目资料库塞进 system prompt。Pi 的做法是把必须知道的规则自动装进提示词，把可能用到的长资料留给工具按需读取。

上下文文件按目录层级合并

loadProjectContextFiles 会读取用户级 agentDir 下的上下文文件，再从当前工作目录向父目录查找项目规则。loadContextFileFromDir 当前识别 AGENTS.md、AGENTS.MD、CLAUDE.md 和 CLAUDE.MD 这些文件名变体。

一个典型的目录关系可以写成这样。

/myorg
├── AGENTS.md                         组织级规则
└── teams
    └── team-a
        ├── CLAUDE.md                 团队规则
        └── projects
            └── app-a
                ├── AGENTS.md         项目规则
                └── src/              当前工作目录

这样组织之后，上层目录可以放通用约束，项目目录再补充具体规则。源码会把不同层级的内容按通用到具体的顺序整理出来，让靠近当前项目的说明拥有更明确的上下文位置。

在 system prompt 中，它们还会被包在清晰的结构边界里。

<project_context>
  <project_instructions path="/myorg/AGENTS.md">
    组织级规则
  project_instructions>

  <project_instructions path="/myorg/teams/team-a/projects/app-a/AGENTS.md">
    项目规则
  project_instructions>
project_context>

XML 标签在这里承担的是边界标记。模型能看到这段内容来自哪个文件，也能区分项目指令和普通对话。对规则类文本来说，来源和范围都比把几段 Markdown 直接拼起来更重要。

Skills 只放目录，正文按需加载

Skills 是另一类容易把 system prompt 撑大的内容。一个 Skill 可能包含完整的操作流程，但一次任务通常只会用到其中一部分。

formatSkillsForPrompt 放入 system prompt 的主要是下面三项。

内容	用途
Skill 名称	让模型知道有哪些能力
Skill 描述	帮模型判断是否匹配当前任务
Skill 路径	匹配后通过 `read` 加载全文

这是一种目录和正文分离的设计。系统不必提前猜模型会用到哪份长文档，只要先告诉它可用能力和读取位置。任务展开后，模型再把真正需要的内容拉进当前上下文。

但懒加载不是越多越好。每轮都必须遵守的规则应该直接放入 system prompt，否则模型可能根本不会主动读取。只有低频、任务相关、篇幅较长的知识，才适合做成按需加载的 Skill。

四、Session Tree 不是聊天列表

到了历史管理阶段，Pi 的一个关键选择会变得很明显。Session 不是一条只能向后追加的聊天列表，而是一棵可以从不同叶子节点继续工作的会话树。

SessionHeader
├── type: "message"         user / assistant / toolResult
├── type: "compaction"
└── type: "branch_summary"

当前请求的上下文，通常由根节点到当前叶子的路径构建出来。用户从旧节点分叉时，路径就会改变。Compaction 和 Branch Summary 也不是只存在于内存里的两段 prompt 文本，而是会作为条目持久化在 Session Tree 中，再由上下文构建逻辑转换成模型可读的 summary message。

这个区别很容易被忽略。

CompactionEntry 和运行时的 CompactionSummaryMessage 不是同一个层次。前者是会话格式里的持久化记录，后者是为了下一次模型调用而生成的消息表示。分支摘要也是一样，Session 中保存 BranchSummaryEntry，构建上下文时再把它转换成模型能理解的内容。

五、Compaction 如何压缩线性历史

当用户让 Agent 连续搜索代码、修改实现、跑测试、根据报错继续修改时，早期消息会逐渐成为上下文负担。Pi 用 Compaction 处理这条线性历史。

触发条件和保留范围

自动压缩的判断可以概括为。

1	contextTokens > contextWindow - reserveTokens

当前官方文档给出的默认值是 reserveTokens = 16384，keepRecentTokens = 20000。它们可以在 ~/.pi/agent/settings.json 或项目内的 .pi/settings.json 中配置。用户也可以通过 /compact [instructions] 手动触发，溢出重试则属于另一种 overflow 原因。

这两个参数分别解决不同的问题。

reserveTokens 给压缩请求和后续工作留出空间，避免已经贴着窗口上限运行。keepRecentTokens 决定压缩后保留多少最近消息，让当前正在进行的工作不被过早总结掉。

Pi 如何选择切分点

触发后，Pi 会从最新消息向前回溯，直到找到大致覆盖 keepRecentTokens 的范围，然后把更早的消息交给摘要请求。

它通常会在 turn 边界切分。一个 turn 从用户消息开始，到下一条用户消息前结束。这样可以尽量避免只保留半个工具调用链，导致模型看到工具调用却看不到对应结果。

如果单个 turn 自己就大到超过保留预算，源码还会允许在 assistant 消息处做更细的切分，并生成 turn-prefix summary。工具调用和工具结果需要成对保留，切分点不会落在孤立的 tool result 上。

摘要保存什么

Pi 当前使用的结构化摘要包含六个部分。

## Goal
## Constraints & Preferences
## Progress
## Key Decisions
## Next Steps
## Critical Context

对于 coding-agent，Progress 不能只写“已经处理了一些文件”。它应该能继续回答这些问题。

哪些文件已经读过
哪些修改已经完成
哪些测试已经运行
哪个方案验证失败以及失败原因
下一步应该从哪里继续

摘要末尾还会记录和。这些信息会和摘要的 details 一起进入后续状态恢复，避免模型压缩后重新猜测工作现场。

摘要请求还会把上一轮摘要作为迭代上下文。这样多次 Compaction 时，新的摘要不是只看最近一小段原始消息，而是可以在旧摘要的基础上继续整理。

压缩条目不会把历史“抹掉”

压缩完成后，Pi 会在 Session Tree 中追加一个 CompactionEntry。条目里至少有摘要内容、firstKeptEntryId 和 tokensBefore，还可以包含本次摘要的 usage 与文件操作详情。

构建下一次 LLM 请求时，Pi 从这个条目恢复摘要，再接上 firstKeptEntryId 之后仍然保留的消息。模型看到的是“摘要加近期尾部”，而不是所有旧消息，也不是一条没有来源的孤立总结。

这使得 Compaction 既能控制 token，又能保留会话格式中的可追溯边界。

Branch Summarization 如何保留失败探索

Compaction 处理一条线上的历史，分支摘要处理的是会话树中的另一种遗忘。

root
├── 方案 A
│   └── 测试发现性能不行，放弃
└── 方案 B
    └── 当前正在继续

用户从 方案 A 的旧节点切换到 方案 B，当前路径通常只包含 root → 方案 B。如果完全丢掉旧分支，模型可能再次提出已经验证失败的方案 A。

Pi 在 /tree 导航到另一条分支时，可以生成 Branch Summary。实现过程可以拆成三步。

找到新旧路径的最近公共祖先，也就是 LCA。
收集 LCA 之后旧分支上的消息，并优先准备较新的内容进入摘要预算。
生成摘要，将它作为 BranchSummaryEntry 追加到当前会话路径。

它和 Compaction 的差异可以放在一张表里。

维度	Compaction	Branch Summarization
触发	接近窗口上限、手动 `/compact` 或溢出重试	`/tree` 切换会话分支
目标	让线性历史继续装得下	带回旧分支的探索成果
选取范围	历史中的可切分前缀	LCA 之后的旧分支路径
持久化条目	`CompactionEntry`	`BranchSummaryEntry`
摘要格式	结构化摘要	使用同一套结构化摘要

这里有一个需要特别修正的细节。Branch Summary 不是另一套固定的五段模板，也不应当被简单理解成固定 2048 token 的摘要。当前 Pi 官方文档说明，Compaction 和 Branch Summarization 共用同一套结构化摘要格式，具体预算会根据待总结内容和上下文空间准备。

分支摘要同样会携带和。Pi 会把工具调用和之前摘要里的文件记录累积起来，避免切换分支后丢掉已经读过或修改过的文件线索。

从一次工具调用看完整链路

假设用户输入的是“修复 auth.ts 的 bug”，一次典型流程大致如下。

用户输入
  ↓
buildSystemPrompt
  ├── 读取全局与项目上下文文件
  ├── 拼接工具描述和 guidelines
  └── 放入 Skills 清单
  ↓
Session Tree 根到当前叶子的路径
  ↓
AgentMessage[]
  ↓ transformContext()
按扩展或运行时策略裁剪、注入
  ↓ convertToLlm()
过滤和转换为模型消息
  ↓
LLM 返回 read("auth.ts")
  ↓
执行 read 工具
  ↓ truncateHead
最多 2000 行、50KB
  ↓
toolResult 回到 AgentMessage 历史
  ↓
下一次请求前检查上下文预算
  ├── 未到阈值，继续 Agent Loop
  └── 到达阈值，追加 CompactionEntry

如果用户中途切换会话树分支，Pi 会在新的路径上追加 BranchSummaryEntry。运行时上下文构建逻辑再把这些持久化条目转换成模型看到的摘要消息。

这条链路里，每一层回答的问题不同。

层	解决的问题
工具截断	单条结果太大怎么办
System prompt 组装	项目规则如何自动进入请求
`transformContext` / `convertToLlm`	内部消息如何变成模型消息
Compaction	线性历史太长怎么办
Branch Summary	旧分支的探索如何不丢

把 reserveTokens 调大，解决不了一条 80KB 的工具结果。把工具输出截得很小，也不会自动告诉模型项目必须使用哪条测试命令。每一层都做窄一点，整个 Agent 才容易观察和调整。

三个设计判断

1. 上下文是每轮重建的投影，不是聊天记录的别名

Session 负责保存可恢复的历史，Agent Context 负责为当前调用选择路径和消息，LLM Message 则是最终发送格式。三者之间存在转换关系。

因此，调试 Agent 失忆时，不能只盯着终端里是否显示过某段文本，还要确认这段文本有没有进入当前叶子路径，是否在 transformContext 中被裁掉，是否能通过 convertToLlm，以及最终是否被工具结果截断或 Compaction 摘要覆盖。

这比把问题归结成“模型记性不好”更接近真实故障边界。

2. 压缩必须保留工作状态，而不只是保留聊天主题

普通聊天摘要可以只保留讨论结论，coding-agent 不行。它还要保留文件关系、修改状态、测试结果和失败尝试。

Pi 把 readFiles 和 modifiedFiles 放进摘要详情，并在分支摘要中继续累积。这说明上下文压缩的目标不是把过去讲得更短，而是让下一次调用可以继续操作同一个工作现场。

如果自己设计摘要模板，Goal 很重要，但 Progress、Key Decisions、Next Steps 和文件操作记录通常更决定恢复质量。

3. 摘要应该是扩展点，而不是黑盒

Pi 提供 session_before_compact 和 session_before_tree 这类扩展事件。扩展可以查看待总结消息、上一轮摘要、文件操作、触发原因和 token 信息，也可以取消默认行为或返回自定义摘要。

这给了应用层一个机会。不同项目可能有不同的状态载体，数据库迁移、前端页面、数据分析 notebook 需要保留的字段并不相同。统一的默认摘要负责兜底，领域扩展负责补充真正影响后续工作的状态。

上下文工程不等于权限控制

还有一个边界需要单独说清楚。

系统提示词可以告诉模型哪些文件不要改，Skills 也可以描述一套操作规范，但这些内容本身不是操作系统级的权限边界。Pi 的官方 README 明确说明，它不内置权限系统，进程会使用启动它的用户权限运行。

因此，上下文工程解决的是模型看什么、记什么、何时读取什么。需要限制文件访问、命令执行或网络能力时，还要使用沙箱、容器、进程权限和工具白名单。把一条规则写进 prompt，不能替代真正的安全隔离。

总结

Pi Agent 的上下文工程可以概括为一条从原始事件到模型消息的流水线。

工具结果先被限制体积，系统提示词把项目规则按来源和层级组织起来，Session Tree 提供当前工作路径，transformContext 和 convertToLlm 再把内部消息变成模型协议。历史接近窗口上限时，Compaction 保存线性工作的状态；切换会话分支时，Branch Summary 带回旧探索的结论。

模型不需要记住一切，但当前这一轮必须看到最有用的那部分。Pi 的实现值得研究的地方，也正在这里。它没有把上下文当作一个越堆越大的文本框，而是把上下文变成了可以截断、加载、压缩、持久化和重新投影的工程对象。

Pi Agent 工具架构设计：三层类型 + 五步管道 + 并行调度 + 错误处理

2026-08-01T09:05:00.000Z

在 Pi Agent 的工具系统中，工具的抽象和执行机制是整个架构的核心。本文系统梳理工具定义的三层类型、调用时的五步管道、并行执行策略，以及错误处理的特殊设计。

一、三层类型：为什么”一个工具”要分三层来定义？

在 Pi Agent 里，一个完整的工具定义被拆成了三层，目的是让不同层职责清晰、扩展性强：

第一层：Tool（一张”名片”）

这是最基础的一层，只定义工具的基本信息：

toolName
description
parameters（Schema）
其他元数据

这一层就像工具的名片，告诉 Agent 它能做什么。

export interface Tool {
  name: string;
  description: string;
  parameters: any;
  // ...
}

第二层：AgentTool（加上了”执行能力”）

在 Tool 的基础上，添加了实际执行逻辑：

execute 方法
错误处理
资源管理等

1
2
3

interface AgentTool extends Tool {
  execute: (params: any) => Promise<any>;
}

这一层是真正可以调用的工具。

第三层：ToolDefinition（产品层再加东西）

在 AgentTool 之上，添加了产品层需要的额外信息：

包装后的执行函数
前置/后置钩子
结果统一格式

interface ToolDefinition extends AgentTool {
  // 包装后的执行函数
  wrappedExecute: (params: any) => Promise<ToolResult>;
}

桥接两层：wrapToolDefinition

为了把第二层的执行能力桥接到第三层，Pi 提供了 wrapToolDefinition 工具：

function wrapToolDefinition(tool: AgentTool): ToolDefinition {
  return {
    ...tool,
    wrappedExecute: async (params) => {
      // 执行前置钩子
      await beforeToolCall?.(params);
      
      try {
        const result = await tool.execute(params);
        return { result, isError: false };
      } catch (err) {
        return { result: err, isError: true };
      }
    }
  };
}

为什么非要分三层？

职责分离：第一层只管描述，第二层管执行，第三层管包装和扩展。
扩展性强：想加新特性（日志、限流、缓存）时，只需要在第三层修改。
可组合性好：可以用不同的 wrapToolDefinition 实现不同的策略。

二、五步管道

模型调用工具时，不是直接调用一个函数，而是走了一套完整的五步管道：

第 1 步：prepareArguments —— 兼容性垫片

处理不同模型返回的参数格式（比如有些模型返回 camelCase，有些 snake_case）。

第 2 步：validateToolArguments —— Schema 验证

使用 JSON Schema 对参数进行严格验证，防止无效输入。

第 3 步：beforeToolCall —— 前置钩子（可阻止执行）

允许开发者在执行前做一些操作（比如权限检查、限流），也可以通过返回 false 来阻止执行。

第 4 步：tool.execute —— 实际执行

真正调用工具的执行逻辑（通常是第二层的 execute）。

第 5 步：afterToolCall —— 后置钩子（可修改结果）

允许开发者在执行后修改结果、添加额外信息等。

管道终点：ToolResultMessage（统一格式的消息）。

这种五步管道让工具调用更加安全、可控、可扩展。

三、并行 vs 串行：一个批次的工具不是”一起跑就完了”

模型经常一次调用多个工具（比如搜索 + 总结 + 数据库查询），但并行执行不能简单用 Promise.all。

Pi 的调度策略是一票否决：

并行执行三阶段设计：
1. 准备阶段（prepare）
2. 并行执行阶段（execute in parallel）
3. 收尾阶段（after parallel）

如果任何一个工具执行失败，会触发一票否决，整个批次被取消并返回错误。

四、永不抛出：工具出错也是一条消息

Pi Agent 工具系统永不抛出异常到 Agent Loop，而是统一返回 ToolResult：

interface ToolResult {
  result: any;
  isError: boolean;
  errorMessage?: string;
}

6 种错误类型 + 1 种产物

工具出错时，会被包装成统一的 ToolResult，而不是直接抛出错误。

关键代码在 tool.execute 的双重防护：

内部主动捕获异常
外部框架兜底包装成消息

为什么”伪装成消息”是最佳处理方式？

因为：

模型最擅长处理消息格式的错误
错误描述越具体，模型纠错能力越强
避免了异常穿透到 Agent Loop，保持 Loop 的稳定性

五、【进阶】Operations 抽象：工具执行不等于系统调用

问题：如果工具直接写死系统调用（如 fs.readFile），那就很难在不同环境中复用。

解法：让工具不直接调系统 API，而是通过最小接口调用。

每个工具定义自己需要的最小接口（比如 ReadOperations），然后通过依赖注入的方式传入具体实现。

这样：

工具代码可以跨环境复用
Mock 测试变得容易
不同 Workspace 切换时行为稳定

总结

Pi Agent 的工具架构通过三层定义 + 五步管道 + 并行调度 + 统一错误消息 + Operations 抽象，实现了高度灵活、可测试、可扩展的工具系统。

这套设计真正做到了把 Agent 的手脚管住。

Pi Agent 工具架构设计：Operations 抽象与 Workspace 切换

2026-08-01T09:05:00.000Z

在 Pi Agent 的工具系统中，Operations 抽象 是核心设计之一。它把工具的执行逻辑与具体文件系统实现解耦，让 Agent 可以在本地、SSH、Docker 等不同环境中灵活切换。

本文主要分享工具架构的核心设计思路，包括抽象接口、依赖注入、闭包固定实例，以及 Workspace 切换机制。

为什么不直接使用 Node.js fs？

很多人第一反应是直接调用 fs/promises：

1 2	await fs.access(path); const buffer = await fs.readFile(path);

这种写法存在几个明显痛点：

强耦合：Tool 与具体文件系统实现绑定（本地磁盘、SSH、Docker 沙箱随便一种都行）。
测试困难：单元测试必须创建真实文件，Mock 成本高。
环境切换麻烦：一旦需要切换后端，Tool 代码几乎需要全部重写。

直观上可以理解为：

Read Tool
      ↓
Node.js fs
      ↓
本地磁盘

工具和具体实现绑定死了，这不是在给 Agent 装手脚，而是把手脚绑死在本地磁盘上了。

Operations 抽象接口

为了解决这个问题，我们定义了一个抽象接口 ReadOperations：

export interface ReadOperations {
    readFile: (absolutePath: string) => Promise<Buffer>;
    access: (absolutePath: string) => Promise<void>;
}

Tool 层只知道调用这个接口，完全不关心下面用的是 fs.readFile 还是 sshClient.readFile。

调用关系变为：

Read Tool
      │
      ▼
ReadOperations（抽象接口）
      │
      ▼
Local / SSH / Docker / Mock 等具体实现

Tool 依赖的是抽象接口，而不是具体实现。

闭包固定实例行为

在创建 Tool 时，我们通常会这样写：

function createReadTool(options?: {
    operations?: ReadOperations;
}) {
    const ops = options?.operations ?? defaultReadOperations;

    return {
        execute: async (path: string) => {
            await ops.access(path);
            return ops.readFile(path);
        }
    };
}

这里用闭包把创建时的 ops 固定在 Tool 实例上，实现了行为稳定的目的。

不管后续怎么切换 Workspace，Tool 实例的行为永远是确定的。

Workspace 切换与多环境支持

本地 Agent 用本地 Operations，SSH Agent 用 SSH Operations，切换 Workspace 时不需要修改 Tool 内部代码：

1 2	const localTool = createReadTool({ operations: localOperations }); const sshTool = createReadTool({ operations: sshOperations });

两个 Tool 可以同时存在，互不干扰。

工具系统五步管道简述

整个工具系统可大致分为五步：

定义：定义 Operations 接口
注册：把具体实现注册到工具系统中
拦截：可选的预处理/后处理
执行：调用 Operations 实例的方法
回收：清理资源或重置状态

我们重点强化了第 4 步的抽象和第 5 步的稳定性。

两层错误处理机制

工具执行时推荐采用两层错误处理：

第一层（工具内部主动识别）：在 execute 方法中主动捕获已知错误类型（如超时、中止、非零退出码），重新包装成具体、可读的错误描述。
第二层（框架兜底被动处理）：工具内部抛出的错误原样透传给框架。

这种做法能给模型提供更有价值的错误反馈。

总结：工具架构的核心思想

Pi Agent 工具架构的核心在于先抽象、再注入、最后稳定。

通过 Operations 抽象 + 依赖注入 + 闭包固定实例的方式，我们实现了：

环境切换的灵活性
测试的简易性
行为稳定性的保证

这样的设计让 Tool 层代码可以在不同 Workspace 间复用，同时保持了清晰的职责边界。

AIO BIO NIO区别？

2026-07-30T09:32:00.000Z

AIO BIO NIO区别？

BIO（同步阻塞 I/O）

BIO 是传统的 I/O 模式，全称为 Block I/O，也叫同步阻塞 I/O。在 BIO 模式下，当我们执行 I/O 操作时，比如读取文件或者网络请求，程序会阻塞，直到 I/O 操作完成后，才能继续执行后面的代码。也就是说，当一个线程在等待 I/O 完成时，它是处于阻塞状态的，不能做其他事情。

NIO（同步非阻塞 I/O）

一个线程管理多个连接

NIO 是对传统 BIO 的改进，它全称是 Non-blocking I/O（非阻塞 I/O）。在 NIO 模式下，I/O 操作不是阻塞的，可以同时处理多个 I/O 请求。与 BIO 不同的是，NIO 使用了 Channel（通道） 和 Buffer（缓冲区） 来进行数据读写，并且它支持 多路复用，这意味着多个 I/O 操作可以共享一个线程来处理，从而大大提高了并发性能。

AIO（异步非阻塞 I/O）

AIO 是 NIO 的进一步升级，叫做 Asynchronous I/O（异步非阻塞 I/O）。在 AIO 模式下，I/O 操作是完全异步的，不需要线程阻塞等待 I/O 完成。AIO 基于事件和回调机制，当 I/O 操作完成时，系统会通知应用程序，程序就能接收到结果。

Kimi K3 发布的一些个人感受

2026-07-17T10:33:45.000Z

Kimi K3 的技术博客里，有一个很容易被忽略、但很关键的细节：

K3 对「思考历史」极度敏感。harness 如果没有完整传回之前的 thinking 内容，生成质量会严重不稳定。

原文大致写了两个触发条件：

harness 没有完整回传历史 thinking 内容
会话中途从别的模型切换到 K3

博客对原因也做了解释。大多数 reasoning 模型，比如 Claude 的 extended thinking、OpenAI 的 o 系列，默认假设是：thinking 是一次性草稿纸。生成完就完成使命了，下一轮不一定需要原样保留。有服务商在服务端加密保存，有的直接允许客户端丢弃。模型训练时，就没指望「未来轮次还能看到这段草稿」。

K3 不是这样训练的。

它是在「每一轮都把之前所有轮次的完整 thinking 摆在上下文里」这个条件下训练出来的。thinking 对 K3 不是草稿纸，而是这个模型认知链条里永久的一部分。它的行为模式，建立在「我永远能看到自己之前想了什么」这个假设之上。

为什么 thinking 不能像 tool result 那样裁

这里有个很有意思的对比，可以类比 agent 上下文里的 tool result 裁剪。

tool result 之所以能被相对安全地裁剪，是因为它读完之后，语义会被显式表达进下一轮的可见回复里。原文没了，但结论已经「抄」到别处留下来了。

thinking 不是这样。

thinking block 里的推理过程，大部分时候不会被完整翻译进最终的可见回复。可见回复往往只是 thinking 里那条推理链的一个结论摘要。中间的探索、排除、纠错过程，只存在于 thinking 本身。

裁掉这部分，模型下一轮拿到的不是「浓缩后的知识」，而是真的丢了一段计算过程。它自己也不知道自己之前想过什么、排除过什么、纠正过什么。

这就是为什么后果是 “quality highly unstable”，而不是「效率下降」。

这不是 KV cache miss 那种成本问题，是模型拿到的信息本身就不完整了，是正确性问题。

从别的模型切过来，也不行

第二个触发条件更有意思。

从别的模型切到 K3，即使把 thinking 内容原样传过去，质量也会不稳定。

因为 K3 训练时看到的历史 thinking，全都是它自己生成的、符合自己训练分布的推理风格。换一个模型生成的 thinking，哪怕格式一样，推理模式和措辞习惯都不同。K3 把这段陌生风格的历史当成自己的思考去续写，容易接不上。

对做 harness 的人意味着什么

对做 agent harness 的人来说，这意味着两件事。

一是不能对 K3 用和别的模型一样的上下文压缩策略。thinking 这部分几乎不能裁。

二是模型路由天然跟 K3 冲突。简单任务用便宜模型、复杂步骤再切强模型，这种常见做法在 K3 上会出问题，因为它没有「接手一个陌生会话」的能力。

模型开源了，但用好它，几乎绑死了兼容的官方 harness。

这大概也是为什么官方会特别推荐 Kimi Code，并建议不要在会话中途切到 K3。

不是模型不够强，是它把「完整可见的自我思考历史」写进了训练假设里。这个假设一旦被 harness 破坏，表现就会立刻塌掉。

RRF 排序融合，混合检索如何统一 BM25 和向量搜索

2026-07-08T17:04:11.000Z

做混合检索时，会碰到一个很朴素的问题。

BM25 说某篇文档得了 18.6 分，向量检索说另一篇文档的相似度是 0.83。到底谁应该排在前面？

18.6 看起来比 0.83 大得多，但这两个数字根本不在同一把尺子上。直接相加没有意义，随手归一化又会受到查询、模型和数据分布影响。

RRF 提供了一个很省心的思路。

既然各路分数不好比较，那就不比较分数，只比较排名。

为什么混合检索需要结果融合

关键词检索和向量检索擅长的事情并不一样。

BM25 根据词项出现情况计算相关性，遇到错误码、产品型号和专有名词时很有优势。查询里明确出现 ERR_CONNECTION_RESET，包含同一字符串的文档通常应该优先返回。

向量检索比较的是语义表示。用户问「服务突然连不上了怎么办」，即使文档里没有完全相同的句子，只写了「连接被远端重置」，它也有机会把内容召回。

两路结果放在一起，覆盖面通常比单一路径更好。麻烦在于，它们返回的原始分数没有统一含义。

BM25 分数会受到词频、文档长度和索引语料影响。向量检索还可能使用余弦相似度、点积或距离，不同模型生成的分数分布也不同。

给两路分数直接设置权重，看起来简单，后面却很容易陷入反复调参。数据规模变了，Embedding 模型换了，原来的权重可能就不合适了。

RRF 绕过了这道题。

RRF 怎么计算

RRF 的全称是 Reciprocal Rank Fusion，也就是倒数排名融合。

对于文档 d，它的融合分数可以写成下面这样。

$score(d) = \sum\_{i=1}^{n} \frac{1}{k + rank\_i(d)}$

rank_i(d) 表示文档 d 在第 i 路结果中的排名。排名从 1 开始。某篇文档没有出现在一路结果中时，那一路就不给它加分。

k 是平滑常数，常见取值是 60。它会削弱第一名和后面名次之间过于悬殊的差距，让多路都排得靠前的文档得到更稳定的优势。

这里最重要的变化是，原始相关性分数消失了。

无论 BM25 返回 18.6，还是向量库返回 0.83，RRF 只问一件事，这篇文档在各自列表里排第几。

手算一个小例子

假设同一个问题得到两组结果。

BM25 的排序是 文档 A、文档 B、文档 C。

向量检索的排序是 文档 B、文档 C、文档 A。

为了让数字更容易观察，这里暂时取 k = 0。真实系统通常会使用更大的平滑常数。

文档 A 在两路中分别排第 1 和第 3，它的分数是

$1/1 + 1/3 = 1.3333$

文档 B 分别排第 2 和第 1，它的分数是

$1/2 + 1/1 = 1.5$

文档 C 分别排第 3 和第 2，它的分数是

$1/3 + 1/2 = 0.8333$

融合后的顺序是 文档 B、文档 A、文档 C。

文档 B 没有在 BM25 中拿到第一，但它在两路都很靠前，所以最终超过了只在一路占据第一的文档 A。这正是 RRF 想保留的共识。

一个可以直接运行的 Python 实现

RRF 本身并不依赖 LangChain 或向量数据库。只要手里已经有多组排序结果，几十行 Python 就能完成融合。

from collections import defaultdict

def reciprocal_rank_fusion(
    rankings: list[list[str]],
    k: int = 60,
) -> list[tuple[str, float]]:
    """Fuse ranked document lists using Reciprocal Rank Fusion."""
    if k < 0:
        raise ValueError("k must be greater than or equal to 0")

    scores: dict[str, float] = defaultdict(float)

    for ranking in rankings:
        seen_in_ranking: set[str] = set()
        for rank, document_id in enumerate(ranking, start=1):
            if document_id in seen_in_ranking:
                continue
            seen_in_ranking.add(document_id)
            scores[document_id] += 1 / (k + rank)

    return sorted(scores.items(), key=lambda item: (-item[1], item[0]))

bm25_results = ["文档A", "文档B", "文档C"]
vector_results = ["文档B", "文档C", "文档A"]

fused_results = reciprocal_rank_fusion(
    [bm25_results, vector_results],
    k=0,
)

for document_id, score in fused_results:
    print(f"{document_id}: {score:.4f}")

运行后得到

1
2
3

文档B: 1.5000
文档A: 1.3333
文档C: 0.8333

代码里额外处理了同一文档在一路结果中重复出现的情况。正常的检索器通常不会返回重复 ID，但在合并多个分片或自行拼装结果时，去重可以避免同一路对某篇文档重复加分。

在 LangChain 里使用 EnsembleRetriever

如果用 LangChain 搭混合检索，RRF 也经常不是自己手写，而是通过 EnsembleRetriever 这类组件完成。

一个典型结构是：先准备一批文档，再分别创建 BM25 检索器和向量检索器，最后把两路检索器交给 EnsembleRetriever 融合。

import jieba
from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever
from langchain.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings

doc_list = [
    "人工智能是计算机科学的一个分支，致力于创造能够模拟人类智能的系统。",
    "机器学习是人工智能的一个子领域，专注于开发能从数据中学习的算法。",
    "深度学习是机器学习的一种方法，使用多层神经网络处理复杂数据。",
    "自然语言处理是人工智能的一个分支，研究计算机与人类语言的交互。",
    "智能助手如小度和天猫精灵使用自然语言处理技术理解用户指令。",
    "自动驾驶汽车利用计算机视觉和深度学习技术识别道路情况。",
    "医疗诊断系统使用机器学习分析患者数据，辅助医生做出诊断决策。",
    "大型语言模型如 GPT 和文心一言能够生成类似人类的文本内容。",
    "计算机视觉技术使机器能够理解和处理视觉信息，如图像和视频。",
    "强化学习是一种机器学习方法，通过奖励和惩罚机制让 AI 学会做决策。",
    "人工智能产业在中国快速发展，成为新的经济增长点。",
    "智能手机的普及改变了人们的生活和工作方式。",
]

def chinese_tokenizer(text):
    return list(jieba.lcut(text))

bm25_retriever = BM25Retriever.from_texts(
    doc_list,
    metadatas=[{"source": f"doc_{i}"} for i in range(len(doc_list))],
    preprocess_func=chinese_tokenizer,
)
bm25_retriever.k = 3

embeddings = HuggingFaceEmbeddings(
    model_name="../bge-large-zh-v1.5",
    model_kwargs={"device": "cpu"},
)

vectorstore = Chroma.from_texts(
    texts=doc_list,
    embedding=embeddings,
    metadatas=[{"source": f"doc_{i}"} for i in range(len(doc_list))],
    persist_directory="./chroma_db_custom_3",
)
vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

ensemble_retriever = EnsembleRetriever(
    retrievers=[bm25_retriever, vector_retriever],
    weights=[0.5, 0.5],
)

docs = ensemble_retriever.invoke("人工智能在医疗领域的应用")
for index, doc in enumerate(docs, start=1):
    print(index, doc.page_content)

这里 BM25 更擅长直接关键词匹配，比如「深度学习」这种查询。向量检索更擅长语义相关但字面不完全一致的问题，比如「智能系统如何理解人类语言」。混合检索则希望把两者的优势放在一起。

原理上，EnsembleRetriever 会把不同检索器返回的结果做融合。它关心的是文档在各路结果中的排名，再结合权重得到最终排序。上面给 BM25 和向量检索都设置了 0.5，意思是先等权看待两路结果。

如果业务里有大量专有名词、编号和错误码，可以适当提高 BM25 的权重；如果查询更偏自然语言表达，可以提高向量检索的权重。但权重最好通过测试集评估，而不是只凭直觉。

测试时可以准备几类问题。

直接关键词匹配：例如「深度学习」
语义相关但没有完全相同关键词：例如「智能系统如何理解人类语言」
混合查询：例如「人工智能在医疗领域的应用」
有歧义的查询：例如「智能产品」

分别观察 BM25、向量检索和混合检索的结果，就能更直观看到 RRF 或加权融合到底改善了什么。

`k` 到底影响什么

如果 k = 0，第一名得到 1 分，第二名得到 0.5 分，第十名只得到 0.1 分。头部名次之间差距很大。

如果 k = 60，第一名约为 0.01639，第二名约为 0.01613，第十名约为 0.01429。名次仍然重要，但变化平缓了很多。

较小的 k 更强调头部名次，较大的 k 更重视多路结果共同提供的信号。60 是常见默认值，不是不可修改的定律。更稳妥的做法，是在自己的查询集上用 Recall、MRR 或 NDCG 等指标评估。

多路权重怎么处理

有些场景会更信任其中一路。例如知识库中包含大量编号和术语，BM25 的精确匹配可能比向量语义更重要。

可以给每一路增加权重。

$score(d) = \sum\_{i=1}^{n} \frac{w\_i}{k + rank\_i(d)}$

这样仍然绕开了原始分数尺度，只调整各路排名信号的重要程度。

不过权重越多，调参成本也会回来。没有离线评估集时，先从等权 RRF 开始，通常比凭感觉设置一堆系数更稳。

RRF 的边界

RRF 简单、鲁棒，但它并不会判断一篇文档是否真的回答了问题。

如果关键词检索和向量检索都召回了错误内容，RRF 只会把这些错误结果重新排序。它也会丢掉原始分数中的置信度信息。某一路的第一名只比第二名高一点，和高出一大截，在 RRF 里没有区别。

所以它更适合做召回结果融合，而不是替代完整的相关性判断。

常见链路会是关键词召回与向量召回并行执行，用 RRF 合并候选，再把靠前的结果交给 Cross-Encoder 或大模型做精排。RRF 负责便宜、稳定地汇总多路意见，Reranker 再仔细判断查询和文档之间的相关性。

检索系统不需要一开始就追求复杂。

当两套评分体系无法直接对话时，先让它们各自投票，再根据名次寻找共识。

这就是 RRF 最实用的地方。

MCP 和 Skill，到底是什么关系？

2026-04-14T07:05:43.000Z

最近看 Agent 相关的项目，经常会同时碰到三个词，Function Calling、MCP 和 Skill。

它们看起来都和「让模型做事」有关，于是很容易混在一起。有人把 MCP 当成更高级的 Function Calling，也有人觉得有了 Skill 就不需要 MCP。

其实它们并不在同一层。

最简短的理解是，Function Calling 负责表达调用，MCP 负责接入能力，Skill 负责组织做事的方法。

一个让模型知道怎么开口，一个把工具接进来，一个告诉 Agent 事情应该怎么完成。

Function Calling 解决的是调用格式

大语言模型只能生成内容。哪怕它说自己要查询天气，也不会真的凭空发出网络请求。

应用需要先把可用函数的名称、用途和参数结构告诉模型。模型判断需要使用工具后，再返回一个结构化调用请求。宿主程序收到请求，执行真实函数，然后把结果放回对话。

一个简化后的工具定义可能长这样。

{
  "name": "get_weather",
  "description": "查询指定城市的天气",
  "parameters": {
    "type": "object",
    "properties": {
      "city": { "type": "string" }
    },
    "required": ["city"]
  }
}

模型并没有亲自执行 get_weather。它只是在回答里表达「我想调用这个函数，参数是某个城市」。真正执行请求的，仍然是模型外面的程序。

所以 Function Calling 更像一种模型和程序之间的调用语言。它解决的是单次调用怎么表达，却没有规定工具该如何独立部署、怎样被发现，也不负责让同一套工具跨客户端复用。

工具只有两三个时，手动维护这些定义并不麻烦。等项目里出现几十个工具，问题就来了。每个应用都要保存一份 schema、路由代码和权限逻辑，工具接口一变，所有接入方还得跟着改。

MCP 处理的正是这一层麻烦。

MCP 解决的是能力接入

MCP 是 Model Context Protocol。它把工具、数据和提示模板包装成遵循统一协议的服务，让支持 MCP 的客户端能够连接、发现并使用这些能力。

一套 MCP 架构里，通常能看到三个角色。

Host 是承载 Agent 的应用，负责管理连接和安全边界
Client 位于 Host 内部，负责与某个 MCP Server 通信
Server 暴露具体能力，例如文件读取、数据库查询或 GitHub 操作

Server 不需要了解上面连接的是哪一种模型。它只按照协议公布自己能提供什么，并响应 Client 发来的请求。

MCP Server 暴露的内容也不只有工具。

Tools 用来执行操作，例如创建文件或调用接口
Resources 用来提供只读上下文，例如文档、日志和数据库记录
Prompts 用来提供可复用的提示模板

它们通过 JSON-RPC 消息交互，可以运行在本地的 stdio 连接上，也可以通过 Streamable HTTP 提供远程服务。

当 Client 连接 Server 后，会先获取能力列表，再把可调用工具转换成模型能够理解的工具定义。模型仍然产生普通的工具调用，Client 负责把请求路由到对应 Server，拿到执行结果后再交还给模型。

从模型视角看，它未必知道 MCP 存在。模型只知道眼前有一批工具可以调用。自动发现、协议转换和请求路由，都是 Host 与 Client 在外面完成的。

因此 MCP 没有取代 Function Calling。很多实现里，它反而会把 MCP 工具转换成模型原生的工具调用格式。

Function Calling 是模型如何发出调用，MCP 是外部能力怎样标准化接进来。

这一点也是 Function Calling 单独使用时最容易碰到的痛点。

如果只靠 Function Calling，每个项目都要自己维护一份工具 schema、调用路由和结果处理逻辑。A 项目接了 10 个工具，B 项目想复用，通常就要复制 schema、重写适配代码；模型供应商的工具调用格式稍有不同，还要再写一层转换。等某个工具参数变了，又得去每个项目里逐个更新。

MCP 的价值就在这里。工具提供方把能力做成独立的 MCP Server，对外统一暴露工具、资源和提示模板。支持 MCP 的 Host 连上来以后，可以自动发现这些能力，而不是每个项目从零手写一遍对接代码。

从模型视角看，它甚至不一定知道 MCP 存在。MCP Client 会把 Server 暴露的工具转换成模型能够理解的调用格式，模型仍然输出普通的工具调用请求，Client 再把请求转发给对应的 Server。换句话说，Function Calling 仍然是模型表达调用的语言，MCP 是管理和复用这些工具的生态层。

这也意味着，MCP 不是让模型凭空拥有执行能力。它需要 Host、Client、Server 和模型工具调用能力一起配合。模型负责提出结构化调用意图，宿主程序负责真正执行和回填结果。

Skill 解决的是工作方法

工具接进来以后，Agent 就一定能把事情做好吗？

不一定。

给一个 Agent 文件系统、终端和 GitHub 工具，只能说明它有能力读文件、跑命令、访问仓库。至于代码审查应该先看哪些文件、检查哪些风险、用什么格式交付，它仍然可能每次做得不一样。

Skill 处理的是这类问题。

一份 Skill 通常会包含名称、适用场景和详细执行说明，还可以附带脚本、参考资料与输出模板。它不是新的工具协议，更接近一份能够被 Agent 主动选择和执行的操作手册。

---
name: code-review
description: 审查代码修改，识别正确性、安全和性能问题
---

# 执行流程

1. 确认修改范围和预期行为
2. 阅读相关代码与测试
3. 运行针对性的检查
4. 按严重程度输出问题和证据

这份 Skill 没有直接提供读取文件的能力。它只规定审查应该怎样展开。真正读取文件时，Agent 仍然需要使用本地工具或 MCP Server 暴露的能力。

所以可以把两者记成一句话。

MCP 让 Agent 有工具可用，Skill 让 Agent 知道怎样把工具组合起来完成任务。

三者怎样一起工作

用一次代码审查就能把整条链路串起来。

用户要求 Agent 审查一批代码修改。Agent 先从可用 Skill 的名称和描述中，发现 code-review 与任务匹配，于是加载它的完整说明。

Skill 要求先确认修改范围。Agent 随后选择 GitHub MCP Server 提供的变更读取工具。模型通过 Function Calling 生成工具名和参数，MCP Client 把调用转发到 Server，再把返回的 diff 送回模型。

接下来，Skill 要求检查测试。Agent 又通过文件系统工具读取相关测试文件，并调用终端运行测试命令。

等证据收集完毕，Agent 按 Skill 规定的严重程度和格式输出报告。

这一次任务里，三者各自做了不同的事。

Function Calling 表达每一次工具调用
MCP 负责发现、连接和路由外部能力
Skill 决定完整任务的步骤、标准与交付形式

少一个都还能运行，但完成度会不一样。只有 Function Calling，工具接入容易散落在各个项目里。只有 MCP，Agent 有很多工具，却不一定有稳定的方法。只有 Skill，流程写得再清楚，没有真实工具也做不了事。

Skill 为什么要渐进式加载

Skill 还能携带脚本、模板和参考文档。如果 Agent 启动时把所有内容一次性塞进上下文，很快就会浪费大量 token，真正的任务信息反而被挤到角落。

更合理的方式是逐层加载。

Agent 启动时只看到每个 Skill 的名称和简介。任务到来后，它只加载匹配 Skill 的完整说明。执行到确实需要某份模板、脚本或参考资料时，再读取对应文件。

这有点像查手册。开始时只看目录，确定需要哪一章后再读正文，遇到具体表格时才翻到附录。不是知道得越多越好，而是在正确的时刻拿到正确的信息。

这个设计看起来只是节省上下文，实际上还在减少干扰。无关规则越少，Agent 越容易把注意力放在当前任务上。

Skill 真正解决的是「重复贴 prompt」的问题。

比如每次让 AI 做代码审查，都要重新说明检查安全漏洞、性能问题、边界条件和输出格式。一个人复制粘贴还勉强能忍，团队里每个人都手写一份标准时，质量就会开始漂移：有人漏掉安全检查，有人格式不统一，有人还在使用旧版规范。

Skill 把这些反复使用的指令、流程、脚本和模板放进一个可维护的文件夹里。一个成熟的 Skill 通常不只是几句提示词，而是有明确的结构。

code-review/
├── SKILL.md
├── scripts/
│   └── check_security.py
├── references/
│   └── review_standards.md
└── assets/
    └── report_template.md

SKILL.md 是核心说明，顶部用 frontmatter 写名称和描述，正文写执行步骤。scripts 可以放自动化脚本，references 放参考资料，assets 放报告模板或其他资源。

这样 Agent 不只是拿到一句「帮我审查代码」，而是拿到一整套可复用的工作方法。需要读文件时，它可以调用 MCP 或本地文件工具；需要安全扫描时，它可以运行 Skill 自带脚本；需要交付结果时，它可以套用 Skill 里的模板。

所以「MCP + Skill」经常会一起出现：MCP 让 Agent 有手，Skill 让 Agent 有操作手册。

实际接入时是什么感觉

我自己理解 MCP，最直观的一点是：它把原来散落在项目里的工具对接，变成了「配置一个 Server，然后让客户端发现它」。

比如在 Claude Desktop 里配置文件系统或 GitHub MCP Server，通常是在配置文件里加上 Server 的启动方式和参数。客户端启动后会连接这些 Server，读取它们暴露的工具列表，然后在对话中按需调用。

开发者不需要在每个对话里手写「read_file 这个函数怎么定义」「GitHub issue 这个接口怎么传参」。这些能力由 MCP Server 标准化提供，Host 负责发现和接入，模型只看到最终可用的工具。

这就是 MCP 和普通 Function Calling 最大的区别：Function Calling 更像一次调用的格式，MCP 更像工具服务的注册、发现和复用机制。

再把边界说清楚

理解这三个概念，关键不是背定义，而是看清它们分别负责哪一段链路。

Function Calling 位于模型与宿主程序之间，让调用能够被结构化表达。

MCP 位于应用与外部能力之间，让工具和数据能够被发现、连接与复用。

Skill 位于任务与执行过程之间，把经验沉淀成可以重复使用的工作方法。

它们不是三个互相争位置的方案，而是一套 Agent 系统里可以同时存在的三层能力。

模型会不会调用，工具能不能接入，任务做得是否稳定。

这三件事，终于可以分开看了。

怎么减少大模型幻觉？

2026-04-10T06:41:35.000Z

大模型最麻烦的时刻，不是它说不知道。

而是它给出一个语气笃定、结构完整、甚至带着出处的答案，等你真的去查，才发现内容根本不存在。

这种现象通常被叫作幻觉。

模型不是在主观撒谎。它的核心任务是根据上下文预测接下来最可能出现的内容。当可靠信息不足时，它仍然可能生成语言上非常合理的答案。读起来顺，不等于事实正确。

所以减少幻觉，不能只靠一句「请不要胡编」。更有效的思路是让模型有依据可用，在依据不足时允许拒答，并让最终结论能够被检查。

普通使用时，先缩小回答空间

问题越开放，模型自由发挥的空间越大。

直接问「介绍一下这个项目」，模型可能自行补充作者、时间线和功能。把要求改成「只根据下面提供的 README，总结项目功能，材料没有提到的信息请标为未知」，回答边界会清楚很多。

一个实用的提示可以包含三件事。

1
2
3

只根据我提供的资料回答。
资料没有覆盖的内容，请明确说不知道，不要补充猜测。
每个关键结论后标出对应的资料片段或编号。

它不能保证模型绝不出错，但能把「自由生成」变成「有边界的整理」。

还可以要求模型把事实、推断和建议分开。事实必须来自材料，推断要说明推理过程，建议则明确标注为建议。三类内容混在一起时，读者很容易把模型的推测当成已经发生的事实。

要求来源，但不要盲信来源

让模型给出处是个好习惯，不过这里还有一个坑。

模型可能连引用也一起编出来。一个看起来很像论文标题的字符串，一组格式规整的作者与年份，都不能自动成为可信证据。

真正有用的是可访问、可定位、能支持当前结论的来源。看到链接后，还要确认页面是否存在、原文是否真的表达了同一件事，以及信息是否已经过时。

医疗、法律、金融和生产环境操作等高风险问题，更不能只看答案写得像不像。至少应该回到官方文档、法规原文或权威机构材料核对。

语言模型很擅长生成「像答案的文本」，验证环节负责判断它是不是答案。

RAG 能降低幻觉，但不会自动消灭幻觉

在应用系统里，常见方案是 RAG，也就是检索增强生成。

用户提出问题后，系统先从知识库中检索相关内容，再把这些内容与问题一起交给模型。模型不必只靠训练阶段记住的知识回答，而是可以参考当前资料。

这对私有知识和频繁更新的信息很有帮助。产品文档更新后，只要重新建立索引，就能让后续回答使用新版本内容，不需要为了每一次文档变化重新训练模型。

可问题并没有到这里结束。

RAG 自己也会产生新的失败路径。

检索器可能没有找到真正相关的文档，也可能召回一堆表面相似但回答不了问题的内容。文档找对了，模型还可能脱离材料继续推断。材料之间互相冲突时，模型也可能悄悄选择其中一份，却不告诉用户冲突存在。

于是系统治理需要覆盖整条链路，而不只是 Prompt。

第一道防线是检索质量

如果交给模型的上下文本身就是错的，后面写再严格的指令也很难救回来。

知识库需要选择合适的切分方式。块太小，完整语义会被切断。块太大，又容易混入很多无关信息。关键词检索适合精确术语，向量检索擅长语义相似，两者可以组合召回，再通过 RRF 一类方法融合结果。

召回之后，还可以使用 Reranker 对查询和候选文档做更细的相关性判断。检索指标也应该单独评估，例如观察正确资料是否进入 TopK，而不是只看模型生成的文字是否顺畅。

这一步不够显眼，却决定了模型手里到底拿到了什么。

第二道防线是低置信度拒答

很多系统最大的错误，是无论检索结果多差，都要求模型必须回答。

如果最高相关性低于阈值，或者多个结果都无法覆盖问题，系统可以直接说明资料不足。拒答不是能力下降，而是系统知道自己的证据边界。

阈值也不能拍脑袋设置。太高会让系统频繁拒绝本来能回答的问题，太低又拦不住无关材料。可以准备一组包含可回答和不可回答问题的验证集，观察不同阈值下的误答率与拒答率，再选择能够接受的平衡点。

允许模型说不知道，往往比教它把每句话写得更肯定重要。

第三道防线是生成约束

检索结果合格后，Prompt 仍然需要给出清楚边界。

可以要求模型只使用提供的上下文，资料不足时返回固定状态，并让每条结论携带来源编号。结构化输出也能让程序更容易检查结果。

{
  "answer": "根据资料生成的回答",
  "citations": ["doc-3#chunk-8"],
  "supported": true
}

这里的 supported 不该完全听模型自我判断。系统仍然需要检查引用 ID 是否存在、引用片段是否进入过上下文，并在必要时验证结论与证据是否一致。

Prompt 是约束，不是安全边界。真正稳定的系统要把能用程序检查的部分留给程序。

第四道防线是引用核查

答案生成后，可以逐条检查关键声明。

最基础的检查，是确认每个引用都对应真实 chunk。再往前一步，可以把单条结论与引用片段交给一个核查模型，判断证据是否支持结论。如果证据只覆盖一半，就删除未被支持的部分，或者把答案降级成不确定表述。

核查模型也可能犯错，所以它更适合当第二道筛网，而不是绝对裁判。对特别重要的操作，还可以要求人工确认后再执行。

一个成本更低的策略，是只核查日期、数字、名称、因果关系和操作指令等高风险声明。没必要给每一句自然语言都增加一次模型调用。

如果把这些方法收束成工程实践，我会优先看四个方向。

第一是 Prompt 强约束。明确告诉模型只能根据提供的资料回答，资料里没有就说不知道，不要为了完整性补充猜测。

第二是检索质量门控。Rerank 分数或相关性分数低于阈值时，系统直接拒答，避免模型在低质量上下文上硬撑。

第三是生成后引用核查。每个关键声明都要能在 chunk 里找到来源依据，找不到就删除、降级或标为不确定。

第四是结构化输出强制溯源。比如让模型输出 JSON，每条结论附上来源编号，方便程序继续检查引用是否存在、证据是否进入过上下文。

如果只选成本最低、见效最快的组合，我会先做 Prompt 强约束和检索质量门控。前者减少模型自由发挥，后者减少系统把错误材料交给模型的概率。生产系统上线前，这两层至少应该有。

评估时不要只看答案好不好读

生成质量很容易被语言流畅度迷惑。

一个更实用的测试集，应该同时包含知识库中有答案的问题、只有部分答案的问题、完全没有答案的问题，以及资料彼此冲突的问题。

然后分别观察几件事。

正确资料有没有被召回
没有证据时系统会不会拒答
答案中的声明能否在引用里找到
引用是否真的支持对应声明
更新知识库后，旧答案是否及时失效

只有把检索、生成和引用拆开测，才知道错误到底发生在哪里。否则看到一个错误答案，很难判断是检索没找到、排序排错了，还是模型拿到正确资料后仍然编了内容。

没有一种办法能把幻觉降到零

提示词约束有用，RAG 有用，Reranker 和引用核查也有用。但它们都不是「安装以后永不出错」的开关。

更可靠的系统，往往不是让模型显得无所不知，而是认真处理不知道的时刻。

有资料就引用资料，证据不足就降低语气，超出边界就明确拒答，高风险结论再交给人确认。

模型负责生成，系统负责约束，使用者负责判断。

把这三层责任分清楚，幻觉才会从一个模糊的模型缺陷，变成可以逐步治理的工程问题。

cookie、session、token

2026-01-26T07:54:15.000Z

cookie
服务端发给客户端，交给客户端保存的数据，每次请求，客户端带上这些数据，服务端就读取这些数据，鉴别身份。
完全由客户端存储，和域名绑定，且不可跨域。
数据大小一般有限制。
容易被伪造，且客户端清除数据就丢失了

session
服务端将客户端的信息保存在服务端，然后将一个sessionId传给客户端，客户端保存起来，下次请求携带sessionId，服务端就通过id找到客户端的身份数据。
真正的数据存储在服务端，数据安全，且数据格式由服务端自定义。
sessionId一般客户端通过cookie的形式存储起来，也有可能通过URL拼接来传递（防止浏览器不支持cookie）。

token
将数据进行加密后，交给客户端存储，客户端每次请求携带这个数据，服务端解密，读出数据。
最常见的实现就是JWT令牌
客户端一般也是通过cookie存储
支持跨域，只要数据能正确解密出来就没问题

总结
可以看到，这三个东西并不是对立的，一般cookie作为底层技术支撑session和token的实现，而session和token的区别主要就在于，session是把数据存在服务端，而token是把数据加密起来交给客户端存储。

MySQL的锁

2025-12-31T17:10:00.000Z

MySQL锁

全局锁：

flush tables with read lock，执行此条命令，整个数据库处于只读状态
unlock tables，释放全局锁，会话断开时，也会自动释放全局锁

一般用来全库逻辑备份

表级锁：MySQL 里面表级别的锁有这几种：

- 表锁：通过lock tables 语句可以对表加表锁，表锁除了会限制别的线程的读写外，也会限制本线程接下来的读写操作。
- 元数据锁：当我们对数据库表进行操作时，会自动给这个表加上 MDL，对一张表进行 CRUD 操作时，加的是 MDL 读锁；对一张表做结构变更操作的时候，加的是 MDL 写锁；MDL 是为了保证当用户对表执行 CRUD 操作时，防止其他线程对这个表结构做了变更。
- 意向锁：当执行插入、更新、删除操作，需要先对表加上「意向独占锁」，然后对该记录加独占锁。意向锁的目的是为了快速判断表里是否有记录被加锁。

行级锁：InnoDB 引擎是支持行级锁的，而 MyISAM 引擎并不支持行级锁。

记录锁(Record Lock)

锁住某行记录，分为读写锁，事务提交后自动释放，例如select * from table_name where id = 1 for update;就给id=1这行记录上了写锁

间隙锁(Gap Lock)

锁住行与行之间的间隙，防止其它事务在间隙中插入数据，产生幻读，间隙锁是不互斥的（如果涉及到记录锁或者临键锁，还是会互斥阻塞），两个事务可以拥有同一段间隙的间隙锁，但要插入数据时发现这段间隙被其它事务锁上了就插不了了。间隙锁是为了解决幻读，防止其它事务在区间内插入数据

临键锁(Next-Key Lock)

间隙锁 + 记录锁，加临键锁的时候是先加间隙锁，后加记录锁，这就有可能出现加间隙锁能成功，加记录锁被阻塞，然后间隙锁与其它事务发生死锁
前开后闭区间，锁住某行以及这一行之前的间隙，如(1, 3]，锁住3这一行和1到3行之间的间隙，因为有记录锁，会产生读写互斥，间隙锁之间不互斥

插入意向锁：

插入意向锁是一个间隙锁，但这个间隙锁实际上锁住的不是一个区间，而是区间中插入的那个点，所以算是一种特殊的间隙锁，插入意向锁和插入意向锁会互斥，即两个事务可以在同一个区间插入，但不能在同一个区间上相同的点插入；插入意向锁与间隙锁互斥，即插入的点所处的区间不能被其它事务的间隙锁锁住

加锁算法

抛开隔离级别谈加锁，都是耍流氓。
InnoDB 的加锁行为必须结合事务隔离级别来理解。

一、读未提交（Read Uncommitted）

增（INSERT）
插入成功后，对新插入的记录加 记录锁，防止其他事务修改该记录。
删（DELETE）
需要获取待删除记录的 记录锁，
保证删除过程中其他事务无法使用该记录，且删除后不能再对其进行操作。
改（UPDATE）
对需要修改的记录加 记录锁。
查（SELECT）
- 普通 SELECT：不上锁，直接读取最新数据（包括未提交的数据）。
- SELECT ... FOR UPDATE / SELECT ... LOCK IN SHARE MODE：
  仅加 记录锁，不加间隙锁。

二、读已提交（Read Committed）

增（INSERT）
插入后对新记录加 记录锁。
删（DELETE）
对目标记录加 记录锁，保证删除过程的安全性。
改（UPDATE）
对被修改的记录加 记录锁。
查（SELECT）
- 普通 SELECT：不上锁，通过 MVCC 读取已提交的数据。
- SELECT ... FOR UPDATE / SELECT ... LOCK IN SHARE MODE：
  仅加 记录锁，不锁间隙。

三、可重复读（Repeatable Read，InnoDB 默认）

增（INSERT）
- 插入时使用 插入意向锁。
- 插入完成后，记录会被加上 记录锁（隐式锁，非立即可见）。
删（DELETE）
对删除范围加 临键锁（Next-Key Lock），
防止其他事务在该区间内插入新记录。
改（UPDATE）
对目标记录加 临键锁。
查（SELECT）
- 普通 SELECT：不上锁，通过 MVCC 读取快照数据。
- SELECT ... FOR UPDATE / SELECT ... LOCK IN SHARE MODE：
  加 临键锁，同时锁记录和间隙。

四、串行化（Serializable）

增（INSERT）
使用 插入意向锁，插入完成后记录被加上 记录锁。
删（DELETE）
对删除区间加 临键锁，防止其他事务插入。
改（UPDATE）
对修改范围加 临键锁。
查（SELECT）
- 普通查询会 自动转化为
  SELECT ... LOCK IN SHARE MODE，
  对读取范围加 临键锁，锁定间隙。

垃圾收集器（CMS-G1-ZGC）与垃圾回收算法

2025-12-30T15:13:00.000Z

垃圾收集器（CMS-G1-ZGC）

CMS 垃圾收集器

JDK1.5时引入，JDK9被标记弃用，JDK14被移除

CMS（Concurrent Mark Sweep，并发标记清除）收集器是以获取最短回收停顿时间为目标的收集器（追求低停顿），它在垃圾收集时使得用户线程和 GC 线程并发执行，因此在垃圾收集过程中用户也不会感到明显的卡顿。

初始标记：Stop The World，仅使用一条初始标记线程对所有与 GC Roots 直接关联的对象进行标记。
并发标记：使用多条标记线程，与用户线程并发执行。此过程进行可达性分析，标记出所有废弃对象。速度很慢。
重新标记：Stop The World，使用多条标记线程并发执行，将刚才并发标记过程中新出现的废弃对象标记出来。
并发清除：只使用一条 GC 线程，与用户线程并发执行，清除刚才标记的对象。这个过程非常耗时。

并发标记与并发清除过程耗时最长，且可以与用户线程一起工作，因此，总体上说，CMS 收集器的内存回收过程是与用户线程一起并发执行的。

CMS 的缺点：

吞吐量低
无法处理浮动垃圾
使用“标记-清除”算法产生碎片空间，导致频繁 Full GC

对于产生碎片空间的问题，可以通过开启 -XX:+UseCMSCompactAtFullCollection，在每次 Full GC 完成后都会进行一次内存压缩整理，将零散在各处的对象整理到一块。设置参数 -XX:CMSFullGCsBeforeCompaction 告诉 CMS，经过了 N 次 Full GC 之后再进行一次内存整理。

G1 通用垃圾收集器

JDK7引入，JDK9取代CMS成为默认垃圾收集器，至少要4G内存才推荐使用G1

G1 是一款面向服务端应用的垃圾收集器，它没有新生代和老年代的概念，而是将堆划分为一块块独立的 Region。当要进行垃圾收集时，首先估计每个 Region 中垃圾的数量，每次都从垃圾回收价值最大的 Region 开始回收，因此可以获得最大的回收效率。

从整体上看， G1 是基于“标记-整理”算法实现的收集器，从局部（两个 Region 之间）上看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。

这里抛个问题

一个对象和它内部所引用的对象可能不在同一个 Region 中，那么当垃圾回收时，是否需要扫描整个堆内存才能完整地进行一次可达性分析？

并不！每个 Region 都有一个记忆集（Remembered Set），用于记录本区域中所有对象引用的对象所在的区域，进行可达性分析时，只要在 GC Roots 中再加上记忆集即可防止对整个堆内存进行遍历。

如果不计算维护 Remembered Set 的操作，G1 收集器的工作过程分为以下几个步骤：

初始标记：Stop The World，仅使用一条初始标记线程对所有与 GC Roots 直接关联的对象进行标记。
并发标记：使用一条标记线程与用户线程并发执行。此过程进行可达性分析，速度很慢。
最终标记：Stop The World，使用多条标记线程并发执行。
筛选回收：回收废弃对象，此时也要 Stop The World，并使用多条筛选回收线程并发执行。

ZGC 收集器（低延迟垃圾收集器）

JDK11推出
与Shenandoah和G1一样，ZGC也采用基于Region 的堆内存布局，但与它们不同的是，ZGC的Region具有动态性——动态创建和销毁，以及动态的区域容量大小。

小型Region：容量固定为 2MB，用于放置小于256KB的小对象
中型Region：容量固定为32MB，用于放置大于等于256KB但小于4MB的对象
大型Region：容量不固定，可以动态变化，但必须为2MB的整数倍，用于放置4MB或以上的大对象。每个大型

Region中只会存放一个大对象，大型Region在ZGC的实现中是不会被重分配（重分配是ZGC的一种处理动作，用于复制对象的收集器阶段）的，因为复制一个大对象的代价非常高昂。
ZGC收集器有一个标志性的设计是它采用的染色指针技术，染色指针是一种直接将少量额外的信息存储在指针上的技术
Linux下64位指针的高18位不能用来寻址，但剩余的46位指针所能支持的64TB内存在今天仍然能够充分满足大型服务器的需要。鉴于此，ZGC的染色指针技术继续盯上了这剩下的46位指针宽度，将其高4位提取出来存储四个标志信息。通过这些标志位，虚拟机可以直接从指针中看到其引用对象的三色标记状态、是否进入了重分配集（即被移动过）、是否只能通过finalize()方法才能被访问到。由于这些标志位进一步压缩了原本就只有46位的地址空间，也直接导致ZGC能够管理的内存不可以超过4TB（2的42次幂）

ZGC不通过原始快照或增量更新来实现并发标记，而是通过染色指针

垃圾回收算法

标记-清除算法：
基础算法，后面两个算法基于此算法改进
算法分为“标记”和“清除”两个阶段：首先标记出所有需要回收的对象，在标记完成后，统一回收掉所有被标记的对象，也可以反过来，标记存活的对象，统一回收所有未被标记的对象。标记过程就是对象是否属于垃圾的判定过程。该算法两个缺点：

执行效率不稳定
内存碎片化

标记-复制算法：
适用于新生代的算法，将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。如果内存中多数对象都是存活的，这种算法将会产生大量的内存间复制的开销，但对于多数对象都是可回收的情况，算法需要复制的就是占少数的存活对象，而且每次都是针对整个半区进行内存回收，分配内存时也就不用考虑有空间碎片的复杂情况，只要移动堆顶指针，按顺序分配即可。算法缺点很明显：少了一半空间

新生代中的对象有98%熬不过第一轮收集。因此并不需要按照1∶1的比例来划分新生代的内存空间。

标记-整理算法：
针对老年代对象的存亡特征，1974年Edward Lueders提出了另外一种有针对性的 “标记-整理”（Mark-Compact）算法，其中的标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向内存空间一端移动，然后直接清理掉边界以外的内存

分代收集算法：
根据对象存活时间将堆划分为新生代和老年代，新生代使用复制算法，老年代使用标记-整理或标记-清除算法。

三色标记法：
可达性分析算法中，标记过程需要stop the world，保证全局获得一致性快照，这个操作可否与用户线程并发？
先来看三色标记法：把遍历对象图过程中遇到的对象，按照“是否访问过”这个条件标记成以下三种颜色：

白色：表示对象尚未被垃圾收集器访问过。显然在可达性分析刚刚开始的阶段，所有的对象都是白色的，若在分析结束的阶段，仍然是白色的对象，即代表不可达，需要被回收
黑色：表示对象已经被垃圾收集器访问过，且所有引用了这个对象的对象都已经扫描过。黑色的对象代表已经扫描过，它是安全存活的，不用被回收，如果有其他对象引用指向了黑色对象，无须重新扫描一遍。黑色对象不可能直接（不经过灰色对象）指向某个白色对象。
灰色：表示对象已经被垃圾收集器访问过，但这个对象上至少存在一个引用还没有被扫描过。是个中间态，当扫描完成后，不会出现这个颜色，整个图非黑即白

可达性分析算法其实就是从GC Roots出发，将图（对象直接的引用关系图）波浪式地由白色转为黑色，其中灰色是黑白之间的过渡色。
这个标记法在用户线程和收集器并发工作下可能存在问题：

是把原本消亡的对象错误标记为存活，这不是好事，但其实是可以容忍的，只不过产生了一点逃过本次收集的浮动垃圾而已，下次收集清理掉就好。

把原本存活的对象错误标记为已消亡，这就是非常致命的后果了，程序肯定会因此发生错误

为什么标记-复制适用于新生代，标记-整理适用于老年代？

新生代需要被清理的对象多，复制只需要复制少量存活对象
老年代存活的对象多，不能使用Eden Survivor那套，不然内存就不够了，当然标记-整理也是一项很负重的操作，但如果不整理，就需要额外使用页表等方式标记哪些空间可用来解决空间碎片化问题，这也会导致额外负担，所以从整个程序的吞吐量考虑，标记-整理是较好的选择
当然老年代也可以先标记-清除，等内存空间碎片化到一定程度时，进行一次标记整理

类加载机制与类加载器

2025-12-28T11:13:00.000Z

类加载机制/类加载器

类加载的完整流程（生命周期）

类从加载到卸载经历 5 个阶段，其中加载、验证、准备、初始化、卸载的顺序是固定的，解析阶段可能与初始化交叉进行：

1. 加载（Loading）

任务：通过类的全限定名（如com.example.User）获取其字节码数据，并生成Class对象。
来源：字节码可来自本地文件、网络、数据库、动态生成（如 CGLib）等。
关键组件：类加载器（ClassLoader）负责此阶段。

2. 验证（Verification）

任务：确保字节码符合 JVM 规范，避免恶意或无效字节码危害虚拟机安全。
验证内容
- 文件格式验证（魔数、版本号等）
- 元数据验证（类继承关系、字段方法合法性）
- 字节码验证（指令逻辑正确性）
- 符号引用验证（常量池引用有效性）

3. 准备（Preparation）

任务
：为类的静态变量分配内存并设置
初始默认值
（非显式赋值）。
- 例如：public static int a = 10;在准备阶段a的值为0（int 默认值），显式赋值在初始化阶段执行。
注意：仅静态变量（类变量）参与此阶段，实例变量在对象创建时分配内存。

4. 解析（Resolution）

任务：将常量池中的符号引用（如类名、方法名）转换为直接引用（内存地址）。
触发时机：通常在初始化前完成，但某些情况下（如动态绑定）会延迟到运行时解析。

5. 初始化（Initialization）执行，真正赋值

任务
：执行类的初始化逻辑，包括：
- 静态变量的显式赋值
- 静态代码块（static {}）的执行
顺序规则
：
- 父类初始化优先于子类
- 静态变量和静态代码块按代码出现顺序执行
触发条件
（主动使用）：
- 创建实例、调用静态方法 / 变量
- 反射（Class.forName()）
- 启动类（含main方法的类）
- 初始化子类时触发父类初始化

什么时候加载类？

JVM规范并没有强制约束，交给虚拟机具体实现来自由把握

类加载器

类加载器负责 “加载” 阶段，通过全限定名获取字节码。JVM 中存在以下几类加载器：

1. 内置类加载器

启动类加载器（Bootstrap ClassLoader）
- 由 C++ 实现（非 Java 类），负责加载 JDK 核心类库（如rt.jar、resources.jar）。
- 最顶层负责加载：
  java.lang.*
  java.util.*
  加载路径：JAVA_HOME/lib由 C/C++ 实现
- 父加载器为null，不继承java.lang.ClassLoader。
扩展类加载器（Extension ClassLoader）
- 加载 JDK 扩展目录（如jre/lib/ext）中的类。
- 父加载器为启动类加载器。
应用程序类加载器（Application ClassLoader）
- 加载用户类路径（classpath）下的类，是默认的类加载器。
- 父加载器为扩展类加载器。

2. 自定义类加载器

继承java.lang.ClassLoader，重写findClass()方法（推荐）或loadClass()方法。
应用场景：热部署、加密类解密、从非标准来源加载类等。

3. 双亲委派模型

定义：类加载时，先委托父加载器加载，父加载器无法加载时才由当前加载器尝试加载。
流程：
自定义加载器 → 应用程序类加载器 → 扩展类加载器 → 启动类加载器
（若所有父加载器均无法加载，则由当前加载器调用findClass()加载）
作用：
- 避免类重复加载（保证同一个类在 JVM 中唯一）。
- 保护核心类库（如java.lang.String不会被恶意替换）。
破坏双亲委派：
可通过重写loadClass()方法实现（如 Tomcat 的类加载器需隔离不同 Web 应用）。

类的卸载

当类的Class对象不再被引用，且加载该类的类加载器被回收时，类会被卸载。
条件：
- 该类的所有实例已被回收。
- 该类的Class对象无引用。
- 加载该类的类加载器已被回收。
注意：JVM 内置加载器加载的类（如核心类库）通常不会被卸载，缘于其加载器始终存在。

关键特性与问题

类的唯一性
一个类的唯一性由 “全限定名 + 类加载器” 共同决定。不同加载器加载的同全限定名类视为不同类。
延迟加载与预加载
- 大多数类采用延迟加载（首次使用时加载）。
- 少数类（如java.lang.Object）会被 JVM 预加载。
常见异常
- ClassNotFoundException：类加载器无法找到指定类（如类路径错误）。
- NoClassDefFoundError：类编译时存在，但运行时未找到（如依赖缺失）。

破坏双亲委派模型：

自定义加载器的话，需要继承 ClassLoader 。如果我们不想打破双亲委派模型，就重写 ClassLoader 类中的 findClass() 方法即可，无法被父类加载器加载的类最终会通过这个方法被加载。但是，如果想打破双亲委派模型则需要重写 loadClass() 方法。

MySQL的MVCC

2025-12-26T17:10:00.000Z

MVCC多版本并发控制

MVCC 的目标：让读操作尽量不阻塞写操作，写操作也尽量不阻塞读操作。

核心机制：

MVCC主要依赖以下机制实现：

数据库行记录中的隐藏字段：最近修改本行数据的事务id、回滚指针指向本行数据的上个版本（其实是指向undo，通过undo计算上一个版本）

•undo log：回滚日志，在insert、delete、update时产生，记载了与操作相反的操作，比如delete操作对应了一条insert日志

•readview：快照读SQL执行时产生的读视图，生成的一个快照，记录了以下字段，用于数据的可见性判断：◦

当前活跃的事务id集合◦
最小活跃事务id◦
预分配事务id，即应该分配的下一个事务id◦
readview创建者id，即本事务id

MVCC如何判断数据的可见性？

首先根据本条数据的是否是由本事务生成的，如果是，那可见，毕竟自己做的修改自己肯定是能看见的
再判断本条数据的事务id是否比最小活跃事务id要小，如果是，那可见，因为这说明这条数据是已经被其它事务提交的，本事务应该可见
再判断本条数据的事务id是否不在活跃事务id集合中，如果不在，那可见，因为这说明也是其它事务提交了的数据

如果本条数据对本事务不可见，就根据隐藏字段 + undo log计算出上一个版本的数据，然后继续判断，直到找到某条对本事务可见的数据

RC 和 RR 隔离级别下 MVCC 的差异

在事务隔离级别 RC 和 RR （InnoDB 存储引擎的默认事务隔离级别）下，InnoDB 存储引擎使用 MVCC（非锁定一致性读），但它们生成 Read View 的时机却不同

在 RC 隔离级别下的 每次select 查询前都生成一个Read View (m_ids 列表)
在 RR 隔离级别下只在事务开始后 第一次select 数据前生成一个Read View（m_ids 列表）

MVCC➕Next-key-Lock 防止幻读

InnoDB存储引擎在 RR 级别下通过 MVCC和 Next-key Lock 来解决幻读问题：

1、执行普通 select，此时会以 MVCC 快照读的方式读取数据

在快照读的情况下，RR 隔离级别只会在事务开启后的第一次查询生成 Read View ，并使用至事务提交。所以在生成 Read View 之后其它事务所做的更新、插入记录版本对当前事务并不可见，实现了可重复读和防止快照读下的 “幻读”

2、执行 select…for update/lock in share mode、insert、update、delete 等当前读

在当前读下，读取的都是最新的数据，如果其它事务有插入新的记录，并且刚好在当前事务查询范围内，就会产生幻读！InnoDB 使用 Next-key Lock 来防止这种情况。当执行当前读时，会锁定读取到的记录的同时，锁定它们的间隙，防止其它事务在查询范围内插入数据。只要我不让你插入，就不会发生幻读

SpringMVC执行流程

2025-12-25T13:05:00.000Z

SpringMVC执行流程

请求先到 DispatcherServlet（前端控制器），它负责调度 HandlerMapping → HandlerAdapter → Controller → ViewResolver → View。

Spring MVC 采用前端控制器模式，所有请求先进入 DispatcherServlet。DispatcherServlet 通过 HandlerMapping 找到对应的 Controller，再通过 HandlerAdapter 调用方法执行。Controller 返回结果后，如果是视图名则交给 ViewResolver 解析并渲染视图；如果是 @ResponseBody，则通过 HttpMessageConverter 转换为 JSON 返回给客户端。

SpringMVC是什么?

Spring MVC 是 Spring 提供的一个基于 MVC 设计模式的 Web 框架，通过 DispatcherServlet 作为前端控制器，结合 HandlerMapping、HandlerAdapter 等组件完成请求的分发和处理，支持注解方式开发，能够方便地实现请求参数绑定和响应结果返回。

MySqL事务特性，隔离级别

2025-12-24T14:34:00.000Z

MySqL事务隔离级别

事务的特性：

原子性：事务要么全部提交成功要么全部失败

一致性：事务操作前和操作后具有完整性约束，数据库保持一致性状态

隔离性：事务执行时相互隔离互不影响，可以防止多个事务并发执行由于交叉执行导致的不一致

持久性：事务操作结束后修改是永久性的，即使关机故障也不会消失

MySQL InnoDB 引擎通过什么技术来保证事务的这四个特性的呢？

持久性是通过 redo log （重做日志）来保证的；
原子性是通过 undo log（回滚日志）来保证的；
隔离性是通过 MVCC（多版本并发控制）或锁机制来保证的；
一致性则是通过持久性+原子性+隔离性来保证；

事务的隔离级别有哪些？

读未提交

最低的隔离级别，会导致脏读、幻读或不可重复读。

读已提交

允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生。这是大多数数据库（如 Oracle, SQL Server）的默认隔离级别。

可重复读

对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。并且，InnoDB 在此级别下通过 MVCC（多版本并发控制）和 Next-Key Locks（间隙锁+行锁）机制，在很大程度上解决了幻读问题。

RR隔离级别甚至连部分情况的可重复读也没解决：事务A先快照读查到数据a=10，事务B更新a=15并提交，事务A再当前读数据，读出来是a=15，两次前后读取不一样。

当前读一定读取“最新已提交版本（Latest Committed Version）”，而不是事务开始时的快照。

可串行化

最高的隔离级别，完全服从 ACID 的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。

事务执行可能出现的问题

脏读：当一个事务读到另一个没有提交事务修改过的数据，此时就发生脏读了。通过读已提交可以避免

不可重复读： 在一个事务内多次读取同一个数据，如果出现前后两次读到的数据不一样的情况，就意味着发生了「不可重复读」现象。

幻读 : 在一个事务内多次查询某个符合查询条件的「记录数量」，如果出现前后两次查询到的记录数量不一样的情况，就意味着发生了「幻读」现象。

RR 隔离级别下如果第一次是快照读、第二次是当前读，确实可能读到不同的值；但严格来说，这并不属于不可重复读，因为比较的是两种不同的读语义。不可重复读只讨论同一种读方式。
在 RC 隔离级别下，虽然普通快照读无法避免不可重复读，但如果显式使用当前读并加锁，同样可以通过锁机制避免前后读取不一致。

Redis的ziplist到ListPack

2025-12-21T14:24:00.000Z

Redis的压缩列表ziplist到紧凑列表listpack

ziplist 的结构（老版本用的）

大概长这样：

[zlbytes][zltail][zllen][entry1][entry2]...[entryN][0xFF]
● *zlbytes*，记录整个压缩列表占用对内存字节数；
● *zltail*，记录压缩列表「尾部」节点距离起始地址由多少字节，也就是列表尾的偏移量；
● *zllen*，记录压缩列表包含的节点数量；
● *0xFF*，标记压缩列表的结束点，固定值 0xFF（十进制255）。

每个 entry 里：

1	[prevlen][encoding][data]

prevlen：前一个 entry 的长度（1 或 5 字节）
encoding：当前 entry 是字符串还是整数，长度是多少
data：真正的数据

listpack 的结构（新版本用的）

大概长这样：

[total_bytes][count][entry1][entry2]...[entryN][0xFF]
total_bytes：整个 listpack 的总字节数
count：entry 的个数（元素数量）
● *0xFF*，标记压缩列表的结束点，固定值 0xFF（十进制255）。

每个 entry 里：

[encoding+len][data][backlen]
[encoding+len]：
1.数据类型（string/int…）
2.字符串长度（完整长度信息）
3.如果长度太长，encoding 会表示“后面几个字节继续存长度”
backlen ：当前整个 entry 的总字节数

注意两点变化：

没有 prevlen 了（不再依赖“记录前一个元素长度”来反向遍历）
多了 backlen（记录自己的完整长度，用来从后往前遍历）

这是 ziplist 被吐槽最多的一个点：级联更新（cascading update）。

1.ziplist 的问题

每个 entry 前面有个 prevlen 字段，记录 前一个 entry 的长度
prevlen 自身可能是 1 字节 或 5 字节
- 如果前一个 entry 变大了，从 253 → 300 字节
- 起初 prevlen = 1 字节，现在需要 5 字节
那么：
- 当前 entry 要扩展 4 字节
- 它变长后，下一个 entry 的 prevlen 又可能从 1 → 5
- 如此继续……导致后面一串 entry 都要重写、搬移内存

结果就是：某个元素变长，可能触发 O(N) 的连锁内存搬移，列表越大越惨，而且实现特别绕，也容易出 bug。

2.listpack 如何改进？

listpack 不再在每个元素开头放 prevlen
改为在 元素末尾 放一个 backlen，记录这个元素自己的长度
反向遍历时：
- 从尾开始，先读 backlen → 退回去这么多字节 → 得到前一个元素起始位置

这样改的一个好处是：

你修改某个元素的长度时，只需要考虑它自己的 backlen
不会像 ziplist 那样，影响后面每一个元素的 prevlen 字段

虽然单个元素变长还是需要移动后面的内存，但不会再产生那种“级联字段变化”的连环改动，整体逻辑简单且更可控。

3. 存储编码更紧凑，节省内存

listpack 是在 ziplist 的经验基础上重新设计的，目标就是：

“既要省内存，又要减少复杂边界情况”

主要变化：

编码种类更合理
- 对整数、短字符串等使用多种变长编码方案
- 比 ziplist 更灵活、更紧凑
去掉多余的头部字段
- ziplist 有 zltail 等字段
- listpack 头部只保留对操作真正有用的字段（总字节数、元素数），结构更轻量
统一整数/字符串编码格式
- 在不同模块（hash、zset、list）里都可以复用 listpack
- 更利于代码维护和优化

总体效果：在很多实际场景中，listpack 比 ziplist 更省内存，尤其是大量小元素时。

4. 性能与安全性方面的改进

① 性能

减少了级联更新的问题，尤其是修改中间元素时更稳定
更简单的编码与解析逻辑，有利于编译器优化、CPU cache 命中

② 安全性

ziplist 曾经出过多次 整数溢出 / 越界 的安全漏洞（CVE），原因之一就是：

设计偏复杂，各种长度字段 + 级联更新
很难做到所有边界都不出错

listpack 从设计上就尽量：

简化字段
减少依赖“前一个元素长度”的逻辑
更好地检查长度合法性

HotSpot 垃圾收集器

2025-12-19T12:43:00.000Z

HotSpot 垃圾收集器

HotSpot 虚拟机提供了多种垃圾收集器，每种收集器都有各自的特点，虽然我们要对各个收集器进行比较，但并非为了挑选出一个最好的收集器。我们选择的只是对具体应用最合适的收集器。

新生代垃圾收集器

Serial 垃圾收集器（单线程）

只开启一条 GC 线程进行垃圾回收，并且在垃圾收集过程中停止一切用户线程，即 Stop The World。

一般客户端应用所需内存较小，不会创建太多对象，而且堆内存不大，因此垃圾收集器回收时间短，即使在这段时间停止一切用户线程，也不会感觉明显卡顿。因此 Serial 垃圾收集器适合客户端使用。

由于 Serial 收集器只使用一条 GC 线程，避免了线程切换的开销，从而简单高效。

ParNew 垃圾收集器（多线程）

ParNew 是 Serial 的多线程版本。由多条 GC 线程并行地进行垃圾清理。但清理过程依然需要 Stop The World。

ParNew 追求“低停顿时间”,与 Serial 唯一区别就是使用了多线程进行垃圾收集，在多 CPU 环境下性能比 Serial 会有一定程度的提升；但线程切换需要额外的开销，因此在单 CPU 环境中表现不如 Serial。

Parallel Scavenge 垃圾收集器（多线程）

Parallel Scavenge 和 ParNew 一样，都是多线程、新生代垃圾收集器。但是两者有巨大的不同点：

Parallel Scavenge：追求 CPU 吞吐量，能够在较短时间内完成指定任务，因此适合没有交互的后台计算。
ParNew：追求降低用户停顿时间，适合交互式应用。

1	吞吐量 = 运行用户代码时间 / (运行用户代码时间 + 垃圾收集时间)

追求高吞吐量，可以通过减少 GC 执行实际工作的时间，然而，仅仅偶尔运行 GC 意味着每当 GC 运行时将有许多工作要做，因为在此期间积累在堆中的对象数量很高。单个 GC 需要花更多的时间来完成，从而导致更高的暂停时间。而考虑到低暂停时间，最好频繁运行 GC 以便更快速完成，反过来又导致吞吐量下降。

通过参数 -XX:GCTimeRadio 设置垃圾回收时间占总 CPU 时间的百分比。
通过参数 -XX:MaxGCPauseMillis 设置垃圾处理过程最久停顿时间。
通过命令 -XX:+UseAdaptiveSizePolicy 开启自适应策略。我们只要设置好堆的大小和 MaxGCPauseMillis 或 GCTimeRadio，收集器会自动调整新生代的大小、Eden 和 Survivor 的比例、对象进入老年代的年龄，以最大程度上接近我们设置的 MaxGCPauseMillis 或 GCTimeRadio。

老年代垃圾收集器

Serial Old 垃圾收集器（单线程）

Serial Old 收集器是 Serial 的老年代版本，都是单线程收集器，只启用一条 GC 线程，都适合客户端应用。它们唯一的区别就是：Serial Old 工作在老年代，使用“标记-整理”算法；Serial 工作在新生代，使用“复制”算法。

Parallel Old 垃圾收集器（多线程）

Parallel Old 收集器是 Parallel Scavenge 的老年代版本，追求 CPU 吞吐量。

CMS 垃圾收集器

初始标记：Stop The World，仅使用一条初始标记线程对所有与 GC Roots 直接关联的对象进行标记。
并发标记：使用多条标记线程，与用户线程并发执行。此过程进行可达性分析，标记出所有废弃对象。速度很慢。
重新标记：Stop The World，使用多条标记线程并发执行，将刚才并发标记过程中新出现的废弃对象标记出来。
并发清除：只使用一条 GC 线程，与用户线程并发执行，清除刚才标记的对象。这个过程非常耗时。

并发标记与并发清除过程耗时最长，且可以与用户线程一起工作，因此，总体上说，CMS 收集器的内存回收过程是与用户线程一起并发执行的。

CMS 的缺点：

吞吐量低
无法处理浮动垃圾
使用“标记-清除”算法产生碎片空间，导致频繁 Full GC

G1 通用垃圾收集器

从整体上看， G1 是基于“标记-整理”算法实现的收集器，从局部（两个 Region 之间）上看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。

这里抛个问题

一个对象和它内部所引用的对象可能不在同一个 Region 中，那么当垃圾回收时，是否需要扫描整个堆内存才能完整地进行一次可达性分析？

并不！每个 Region 都有一个 Remembered Set，用于记录本区域中所有对象引用的对象所在的区域，进行可达性分析时，只要在 GC Roots 中再加上 Remembered Set 即可防止对整个堆内存进行遍历。

如果不计算维护 Remembered Set 的操作，G1 收集器的工作过程分为以下几个步骤：

初始标记：Stop The World，仅使用一条初始标记线程对所有与 GC Roots 直接关联的对象进行标记。
并发标记：使用一条标记线程与用户线程并发执行。此过程进行可达性分析，速度很慢。
最终标记：Stop The World，使用多条标记线程并发执行。
筛选回收：回收废弃对象，此时也要 Stop The World，并使用多条筛选回收线程并发执行。

Redis网络模型

2025-12-17T13:43:00.000Z

Redis网络模型（io多路复用）

阻塞IO(Blocking IO)

假设服务端只开启一个线程处理请求，第一个请求到来，开始调用内核read函数，然后就会发生阻塞，第二个请求到来时服务端将无法处理，只能等第一个请求读取完成。这种方式的缺点很明显，每次只能处理一个请求，无法发挥cpu多核优势，性能低下。

为了解决这个问题，我们可以引入多线程，这样就可以同时处理多个请求了，但服务端可能同时有成千上万的请求需要处理，随之而来的是线程数膨胀，频繁创建、销毁线程带来的性能影响，当然我们可以使用线程池，但服务能处理的总体数量就会受限于线程池线程数量。

非阻塞IO(NON-Blocking IO)

相比阻塞IO，非阻塞IO会立即返回，调用者不会阻塞，此时可以做一些其它事情，例如处理其它请求。但是非阻塞IO需要主动轮询是否有数据需要处理，且这种轮询需要从用户态切换到内核态这，假如没有数据产生就会有很多空轮询，白白浪费cpu资源。

阻塞IO、非阻塞IO，要么需要开启更多线程去处理IO，要么需要从用户态切换到内核态轮询IO事件，那么有没有一种机制，用户程序只需要将请求提交给内核，由内核用少量的线程去监听，有事件就通知用户程序呢？这就是IO多路复用。

IO多路复用(IO Multiplexing)

IO多路复用机制是指一个线程处理多个IO流，多路是指网络连接，复用指的是同一个线程。
如果简单从图上看IO多路复用相比阻塞IO似乎并没有什么高明之处，假设服务只处理少量的连接，那么相比阻塞IO确实没有太大的提升，但如果连接数非常多，差距就会立竿见影。
首先IO多路复用会提交一批需要监听的文件句柄（socket也是一种文件句柄）到内核，由内核开启一个线程负责监听，把轮询工作交给内核，当有事件发生时，由内核通知用户程序。这不需要用户程序开启更多的线程去处理连接，也不需要用户程序切换到内核态去轮询，用一个线程就能处理大量网络IO请求。
redis底层采用的就是IO多路复用模型，实际上基本所有中间件在处理网络IO这一块都会使用到IO多路复用，如kafka,rocketmq等，所以本次学习之后对其它中间件的理解也是很有帮助的。

select/poll/epoll

linux最开始提供的是select函数，方法如下：

1	select(int nfds, fd_set r, fd_set w, fd_set e, struct timeval timeout)

该方法需要传递3个集合，r,e,w分别表示读、写、异常事件集合。集合类型是bitmap，通过0/1表示该位置的fd(文件描述符，socket也是其中一种)是否关心对应读、写、异常事件。例如我们对fd为1和2的读事件关心，r参数的第1,2个bit就设置为1。

用户进程调用select函数将关心的事件传递给内核系统，然后就会阻塞，直到传递的事件至少有一个发生时，方法调用会返回。内核返回时，同样把发生的事件用这3个参数返回回来，如r参数第1个bit为1表示fd为1的发生读事件，第2个bit依然为0，表示fd为2的没有发生读事件。用户进程调用时传递关心的事件，内核返回时返回发生的事件。

select存在的问题：

大小有限制。为1024，由于每次select函数调用都需要在用户空间和内核空间传递这些参数，为了提升拷贝效率，linux限制最大为1024。
这3个集合有相应事件触发时，会被内核修改，所以每次调用select方法都需要重新设置这3个集合的内容。
当有事件触发select方法返回，需要遍历集合才能找到就绪的文件描述符，例如传1024个读事件，只有一个读事件发生，需要遍历1024个才能找到这一个。
同样在内核级别，每次需要遍历集合查看有哪些事件发生，效率低下。

poll函数对select函数做了一些改进

poll(struct pollfd *fds, int nfds, int timeout)

struct pollfd {
int fd;
short events;
short revents;
}

poll函数需要传一个pollfd结构数组，其中fd表示文件描述符，events表示关心的事件，revents表示发生的事件，当有事件发生时，内核通过这个参数返回回来。

poll相比select的改进：

传不固定大小的数组，没有1024的限制了（问题1）
将关心的事件和实际发生的事件分开，不需要每次都重新设置参数（问题2）。例如poll数组传1024个fd和事件，实际只有一个事件发生，那么只需要重置一下这个fd的revent即可，而select需要重置1024个bit。

poll没有解决select的问题3和4。另外，虽然poll没有1024个大小的限制，但每次依然需要在用户和内核空间传输这些内容，数量大时效率依然较低。

这几个问题的根本实际很简单，核心问题是select/poll方法对于内核来说是无状态的，内核不会保存用户调用传递的数据，所以每次都是全量在用户和内核空间来回拷贝，如果调用时传给内核就保存起来，有新增文件描述符需要关注就再次调用增量添加，有事件触发时就只返回对应的文件描述符，那么问题就迎刃而解了，这就是epoll做的事情。

epoll对应3个方法

1
2
3

int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

epoll_create负责创建一个上下文，用于存储数据，底层是用红黑树，以后的操作就都在这个上下文上进行。
epoll_ctl负责将文件描述和所关心的事件注册到上下文。
epoll_wait用于等待事件的发生，当有有事件触发，就只返回对应的文件描述符了。

select 底层是位图数组，限制就是会被数组长度限制，只有1024大小，内核轮询这个事件是否就绪，如果有的话内核态会把用户态的参数拷进内核空间然后检测每个的状态，select() 返回时，内核会把修改后的 fd_set（就绪标记）拷回用户空间，这样子的开销是比较大的，每次都需要扫描，拷贝。

poll底层的话是个链表，他的话解决了select的大小限制问题，但是还是没有解决用户态与内核态之间的问题

epoll的话他底层是个红黑树，他有三个函数，creat，ctl，wait，他的改进是用户在修改的时候，内核会把信息拷入内核数据结构，当内核返回就绪事件时候，epoll_wait会把准备好的事件批量拷贝到用户提供的缓冲区

ConcurrentHashMap底层原理

2025-11-28T05:05:00.000Z

ConcurrentHashMap底层原理

jdk1.7是数组加链表，它在对象中保存了一个Segment数组。每个Segment元素类似于一个Hashtable；这样，在执行put操作时首先根据hash算法定位到元素属于哪个Segment，然后对该Segment加锁即可，不同的Segment可以并发put。而Segment的锁实现其实是ReentrantLock

jdk1.8则是采用了数组+链表/红黑树，他舍弃了Segment数组，用的是CAS + synchronized

1.7put流程：

为输入的Key做Hash运算，得到hash

通过hash，定位到对应的Segment对象（根据hash值的高4位（根据Segment数量决定是高几位，如果是32个Segment，就是高5位），找到对应Segment）
获取可重入锁
再次通过hash值，定位到Segment当中数组的具体位置
插入或覆盖HashEntry对象
释放锁

1.7get流程：

为输入的key做Hash运算，得到hash
通过hash，定位到对应的Segment对象
再次通过hash，定位到Segment当中数组的具体位置

为什么get不需要上锁？因为使用了大量的volatile（Node中的val和next是volatile）

1.8put流程

检验key和value不能为null
进入死循环
如果第一次添加元素，初始化table，使用CAS保证线程安全，然后重新进入循环
如果头节点为null，CAS将自己设置为头节点，成功则break，失败则重新进入循环
如果头节点是ForwardingNode，说明这个桶正在进行扩容，则帮忙进行扩容，然后重新进入循环
到了这里说明需要往桶下标的非头节点中添加元素，此时使用synchronized，锁对象是头节点
再次确认链表头节点有没有被移动
如果是链表，走链表put操作，如果有相同的key则更新，否则添加
如果是红黑树，走红黑树put操作，如果有相同的key则更新，否则添加
释放锁，判断是否需要树化，然后break
使用累加单元数组进行size累加，判断是否需要扩容

1.8get流程：无锁获取，因为Node[]和Node中的val和next有volatile

扩容

第一部分是构建一个 nextTable，它的容量是原来的两倍，这个操作是单线程完成的。

第二个部分是将原来 table 中的元素复制到 nextTable 中，主要是遍历复制的过程。遍历是从后往前遍历原table
得到当前遍历的数组位置 i，然后利用 tabAt 方法获得 i 位置的元素：

如果这个位置为空，就在原 table 中的 i 位置放入 forwardNode 节点，这个也是触发并发扩容的关键；

如果这个位置是 Node 节点（fh>=0），并且是链表的头节点，就把这个链表分裂成两个链表，把它们分别放在 nextTable 的 i 和 i+n 的位置上（桶下标不变的留在原地，变的放到 i + n 处）；处理完后头节点变成forwardNode（如果是链表，则复制值创建新节点对象扩容，如果是一个节点，则挪动元素扩容）

如果这个位置是 TreeBin 节点（fh<0），也做一个反序处理，并且判断是否需要 untreefi，把处理的结果分别放在 nextTable 的 i 和 i+n 的位置上；处理完后头节点变成forwardNode

遍历所有的节点，就完成复制工作，这时让 nextTable 作为新的 table，并且更新 sizeCtl 为新容量的 0.75 倍，完成扩容。

扩容会把正在扩容的头结点设置成一个特殊结点，然后从get，put的角度说

扩容时有其余线程来get：如果头节点是forwardNode，那么就去新table中get，否则，在原table中查询，又因为迁移链表时是深拷贝扩容，所以get能查找到对应元素，不会出现并发问题

扩容时有其余线程来put：
如果要put的桶下标还不在扩容中，直接put
如果put的桶下标正在扩容中，只能阻塞
如果put的桶下标是forwarding，此时不能往新table中put，因为此时新table还没扩容完成，put可能产生并发问题，此时会去协助扩容

SpringIOC

2025-11-24T10:51:00.000Z

什么是 IoC?

IoC （Inversion of Control ）即控制反转/反转控制。它是一种思想不是一个技术实现。描述的是：Java 开发领域对象的创建以及管理的问题。

例如：现有类 A 依赖于类 B

传统的开发方式 ：往往是在类 A 中手动通过 new 关键字来 new 一个 B 的对象出来
使用 IoC 思想的开发方式 ：不通过 new 关键字来创建对象，而是通过 IoC 容器(Spring 框架) 来帮助我们实例化对象。我们需要哪个对象，直接从 IoC 容器里面去取即可。

从以上两种开发方式的对比来看：我们 “丧失了一个权力” (创建、管理对象的权力)，从而也得到了一个好处（不用再考虑对象的创建、管理等一系列的事情）

为什么叫控制反转?

控制：指的是对象创建（实例化、管理）的权力
反转：控制权交给外部环境（IoC 容器）

IoC 解决了什么问题?

IoC 的思想就是两方之间不互相依赖，由第三方容器来管理相关资源。这样有什么好处呢？

对象之间的耦合度或者说依赖程度降低；
资源变的容易管理；比如你用 Spring 容器提供的话很容易就可以实现一个单例

IOC和DI的区别？

IoC（控制反转, Inversion of Control） 是一种设计思想/原则：把对象的控制权（创建、生命周期、依赖获取等）从应用程序代码中“反转”到框架或容器。也就是说：不是对象去主动创建或查找依赖，而由外部容器来负责提供（控制）这些依赖。

DI（依赖注入, Dependency Injection） 是实现 IoC 的一种具体技术/方式——把依赖（对象）“注入”到目标对象中。常见注入方式：构造器注入、Setter 注入、字段注入。

IoC 是设计思想，DI 是具体的实现方式；

IoC 是理论，DI 是实践；

Bean 的生命周期

第一个阶段是实例化。Spring 容器会根据 BeanDefinition，通过反射调用 Bean 的构造方法创建对象实例。如果有多个构造方法，Spring 会根据依赖注入的规则选择合适的构造方法。

第二阶段是属性赋值。这个阶段 Spring 会给 Bean 的属性赋值，包括通过 @Autowired、@Resource 这些注解注入的依赖对象，以及通过 @Value 注入的配置值。

第三阶段是初始化。这个阶段会依次执行：

@PostConstruct 标注的方法
InitializingBean 接口的 afterPropertiesSet 方法
通过 @Bean 的 initMethod 指定的初始化方法

第四阶段是使用 Bean。比如我们的 Controller 调用 Service，Service 调用 DAO。

最后是销毁阶段。当容器关闭或者 Bean 被移除的时候，会依次执行：

@PreDestroy 标注的方法
DisposableBean 接口的 destroy 方法
通过 @Bean 的 destroyMethod 指定的销毁方法

项目启动时Spring的IoC会做什么？

第一件事是扫描和注册 Bean。IoC 容器会根据我们的配置，比如 @ComponentScan 指定的包路径，去扫描所有标注了 @Component、@Service、@Controller 这些注解的类。然后把这些类的元信息包装成 BeanDefinition 对象，注册到容器的 BeanDefinitionRegistry 中。这个阶段只是收集信息，还没有真正创建对象。

第二件事是 Bean 的实例化和注入。这是最核心的过程，IoC 容器会按照依赖关系的顺序开始创建 Bean 实例。对于单例 Bean，容器会通过反射调用构造方法创建实例，然后进行属性注入，最后执行初始化回调方法。

HashMap

2025-11-23T06:19:00.000Z

HashMap

JDK 7 中 HashMap 的数据结构是数组+链表。

JDK 8 中 HashMap 的数据结构是数组+链表+红黑树。

它在链表长度大于8且数组长度大于64时候会把链表转换成红黑树

HashMap 的初始容量是 16，随着元素的不断添加，HashMap 就需要进行扩容，阈值是capacity * loadFactor，capacity 为容量，loadFactor 为负载因子，默认为 0.75。

扩容后的数组大小是原来的 2 倍，然后把原来的元素重新计算哈希值，放到新的数组中。

负载因子（load factor）是一个介于 0 和 1 之间的数值，用于衡量哈希表的填充程度。它表示哈希表中已存储的元素数量与哈希表容量之间的比例。

负载因子过高（接近 1）会导致哈希冲突增加，影响查找、插入和删除操作的效率。
负载因子过低（接近 0）会浪费内存，因为哈希表中有大量未使用的空间。

HashMap 的put过程：

1.他会先对key计算扰动hash，通过key.hashCode() ^ (key.hashCode() >>> 16)计算，这样的目的是为了高16位的熵混进去低16位，减少碰撞。

2.判断当前是不是第一次添加是的话就创建一个默认长度16，负载因子0.75的数组。

3.开始计算数组下标index，通过前面计算的hash & (n - 1)来确定位置这里的n是2的次幂

4.然后获取当前数组中对应的数据

5.数组为空，底层会创建一个键值对对象，直接放进去就行了

6.不为空

6.1.如果当前插入的键值对与数组的键值对哈希值一样，也就是插入的键值与插入后的键值一样就把调整当前元素指针，在后面进行替换操作

6.1.已经是TreeNode，走红黑树的添加或更新逻辑

6.2.是普通Node，走链表的添加或更新逻辑，如果达到树化条件，走树化逻辑

添加后、返回前检查容量是否达到扩容阈值，如果达到，进行扩容

为什么HashMap的容量是2的n次方

1.用位运算 `(n - 1) & hash` 快速代替取模 `% n`

在n为偶数时候 n - 1为奇数（n - 1）& hash等价于 hash % n 并且位运算比取模快得多

2.保证哈希值在桶上的分布尽可能均匀，避免部分桶永远用不到

2 幂次方刚好是偶数，偶数-1 是奇数，奇数的二进制最后一位是 1，也就保证了 hash &(length-1) 的最后一位可能为 0，也可能为 1（取决于 hash 的值），这样可以保证哈希值的均匀分布。

3.方便扩容时用 `oldCap` 这一位快速判断元素新位置（JDK1.8 的优化）

桶里每个节点的新位置只和这一位有关：

// oldCap 一定是 2 的幂，比如 16(10000b)
if ((hash & oldCap) == 0) {
    // 这位是 0：留在原来的 index
    newIndex = oldIndex;
} else {
    // 这位是 1：去到 index + oldCap
    newIndex = oldIndex + oldCap;
}

JDK 1.8 扩容时利用 hash & oldCap 这位来判断元素是留在原索引还是移动到 index + oldCap，极大简化了 rehash 的过程，这个优化也依赖容量是 2 的幂。

重写HashMap的equal和hashcode方法需要注意什么？

如果o1.equals(o2)，那么o1.hashCode() == o2.hashCode()总是为true的。
如果o1.hashCode() == o2.hashCode()，并不意味着o1.equals(o2)会为true。

HashMap 的扩容机制和扩容过程（JDK1.8）

1）何时扩容？

有个阈值：threshold = capacity * loadFactor
- 默认：capacity = 16，loadFactor = 0.75
- 所以初始 threshold = 12
当 size > threshold 时，进行扩容：
- 数组长度 ×2，比如 16 -> 32。

2）扩容过程（`resize()`）

创建一个新数组 newTable，长度 = 原来 2 倍。
遍历旧数组每个桶：
- 如果桶为空，跳过。
- 如果桶里只有一个节点，直接搬到新数组对应位置。
- 如果桶是红黑树，拆成两棵或调整后搬到新数组中。
- 如果桶是链表：
  - JDK1.8 做了一个优化：
    - 利用 e.hash & oldCap 的结果来判断节点在新数组中的位置：
      - 如果为 0：节点留在原位置 index。
      - 如果为 1：节点去到 index + oldCap。
  - 这样链表可以拆成两个链表，过程更快，也避免 1.7 里“倒序 + 死循环”的问题。

扩容是最重的操作：需要重新分布所有元素，所以尽量别频繁扩容（比如一开始就知道大概数量，可以传一个合适的 initialCapacity）。

HashMap 出现 Hash 冲突时怎么办？何时链表进化成红黑树？何时退化？

1）hash 冲突的解决方式

HashMap 使用的是 “拉链法”：
- 数组 + 链表/红黑树。
- 同一个桶上的多个元素通过 next 指针连成一条链，或组织成一棵红黑树。

2）链表 -> 红黑树（树化）的条件（JDK1.8）

满足 两个条件 才会树化：

单个桶中的链表长度 ≥ TREEIFY_THRESHOLD（默认 8）。
整个 table 的长度 ≥ MIN_TREEIFY_CAPACITY（默认 64）。

不满足第二个条件时，会优先选择扩容而不是树化。

原因：

如果表太小，说明整体碰撞重；这时扩容可以让数据分摊到更多桶里，比急着树化更划算。

3）红黑树 -> 链表（退化）的条件

当树中的节点个数 ≤ UNTREEIFY_THRESHOLD（默认 6）时，
remove树节点时，如果root、root.left、root.right、root.left.left有一个为null（在移除之前检查），也会退化成链表

JDK8为什么改用尾插法？

JDK8引入了红黑树，那么就可以插入时顺便遍历一遍当前桶有多少元素，决定是否转为红黑树
避免多线程下扩容可能产生的死循环

扩容的时候每个节点都要进行位运算吗？

不需要。HashMap 会通过 (e.hash & oldCap) 来判断节点是否需要移动，0 的话保留原索引；1 才需要移动到新索引（原索引 + oldCap）。

这样就避免了 hashCode 的重新计算，大大提升了扩容的性能。

所以，哪怕有几十万条数据，可能只有一半的数据才需要移动到新位置。另外，位运算的计算速度非常快，因此，尽管扩容操作涉及到遍历整个哈希表并对每个节点进行判断，但这部分操作的计算成本是相对较低的。

String的hashCode()如何设计的，为啥每次乘的是31

字符串中的每个字符都可以表现为一个数字，称为Si，其中i的范围是0 ~ n - 1
散列公式为：S0 * 31 ^ (n - 1) + S1 * 31 ^ (n - 2) + S2 * 31 ^ (n -3) + … + Sn-1 * 31 ^ (0)
31代入公式有较好的散列特性，并且31 * h可以被优化为 h << 5 - h
但这算法时间复杂度o(n)

哈希冲突解决方法:

拉链法：哈希冲突时，同一个哈希槽拉成一个链表，HashMap采用该方法
开放寻址：寻找其他位置，这就保证了一个哈希槽最多存有一个元素
线性探测：哈希冲突时，按顺序往后查找，直到找到第一个为空的槽位，ThreadLocalMap采用该方法
二次探测：与线性探测类似，但有规律，比如每次步长是1，2，4，8，16。。。
再哈希法：哈希冲突时，换个哈希函数再次哈希

Volatile原理

2025-11-22T16:56:00.000Z

Volatile原理

MySQL 联合索引的最左匹配原则

2025-11-21T17:25:00.000Z

MySQL 联合索引的最左匹配原则

执行计划基础知识

possible_keys：可能用到的索引

key：实际用到的索引

type:

ref：当通过普通的二级索引列与常量进行等值匹配的方式询某个表时
const：当我们根据主键或者唯一得二级索引列与常数进行等值匹配时，对单表的访问方法就是 const
range:如果使用索引获取某些单点扫描区间的记录。
index：当可以使用覆盖，但需要扫描全部的索引记录时。

Extra:

Using index 索引覆盖
Using Where 当某个搜索条件需要在 server 层进行判断时
Using index for skip scan 跳跃扫描
Using index condtion 索引下推

最左匹配原则

最左优先，以最左边的为起点任何连续的索引都能匹配上。同时遇到范围查询(>、<、between、like)就会停止匹配。

比如有联合索引 [a、b、c]，where 过滤条件中哪些排列组合可以用到索引？（比如这种：where a=xxx b=xxx and c=xxx）

以下排列组合都会走索引： a、ab、ac、ba、ca、abc、acb、bac、bca、cab、cba。必须有一个 a，排列组合中的顺序会被优化器优化，所以不用关心顺序。

以下排列组合不会走索引： b、c、bc、cb。因为没有 a。

关于范围查询： a=xxx and b<10 and b > 5 and c =xxx，c 字段用不到索引，因为 b 是一个范围查询，遇到范围查询就停止了。

by -https://juejin.cn/post/7283832557502693413

redis做为缓存，mysql的数据如何与redis进行同步呢？（双写一致性）

2025-11-14T13:27:00.000Z

redis做为缓存，mysql的数据如何与redis进行同步呢？（双写一致性）

在项目中，我们主要通过 Redisson 的读写锁机制 来保证数据的强一致性。

当执行读取操作时，我们会加上读锁（共享锁），这样可以做到：

读读不互斥；
读写互斥。

而在更新数据时，我们会加上写锁（排他锁），此时写写、读写都互斥。
这样可以确保在写入数据库的同时，其他线程无法读取缓存数据，从而避免出现脏读或不一致的情况。
这里需要注意的一点是：读写方法必须使用同一把锁，才能真正保证互斥关系成立。

除了使用分布式锁，我们也考虑过使用 “延迟双删”策略 来实现最终一致性。

具体做法是：

先删除缓存；
再更新数据库；
最后延时一段时间后，再删除一次缓存。

不过，延迟的时间点很难精确把握。在延时窗口内仍可能出现脏数据问题，无法满足强一致性场景，因此我们最终没有采用这种方式。

在我最近做的项目中（例如简历中提到的 xxxx 功能），
系统对数据一致性的实时性要求没有那么高，可以接受一定的同步延时。

因此我们采用了 阿里巴巴的 Canal 组件 来实现最终一致性的数据同步。

Canal 的原理是：

将自己伪装成 MySQL 的从节点；
通过监听 binlog（数据库增删改日志） 来捕获数据变更；
Canal 服务解析 binlog 后，将变更数据推送给客户端；
客户端根据变更内容更新或删除 Redis 缓存。

这种方式的优点是：

不需要修改业务代码；
同步过程自动化；
能在大多数业务场景下保证“最终一致性”。

Redis分布式锁redisson看门狗机制

2025-11-14T12:24:00.000Z

Redis分布式锁方案

使用 Redis 的 SET key value NX EX实现分布式锁时，主要问题是锁过期时间不好设置：如果设置过短，业务未完成锁就过期；设置过长，会降低系统并发度。为此可以使用 Redisson 封装的分布式锁，它内部通过「看门狗机制」自动续期锁（默认锁 30 秒，每 10 秒续期一次），同时通过 Lua 脚本保证加解锁的原子性，从而确保分布式环境下的并发安全。

Redisson分布式锁自动续约机制（看门狗）

线程1尝试tryLock锁未指定锁的过期时间获取成功后会自动启动看门狗机制

初始加锁：

当调用 lock() 时，Redisson 会通过 Lua 脚本向 Redis 发送加锁命令，设置锁的初始过期时间为 LockWatchdogTimeout（默认 30 秒）。

锁的数据结构为 Hash，键为锁名称，field 为线程 ID，value 为重入次数。

启动定时任务：

加锁成功后，Redisson 会启动一个后台定时任务（通过 Netty 的 HashedWheelTimer 实现），每隔 10 秒执行一次。

续期逻辑：

定时任务通过lua脚本检查锁是否存在并且被当前线程持有

若条件满足，则通过 pexpire 命令将锁的过期时间重置为 LockWatchdogTimeout（30 秒）。

续期成功后，继续等待下一个检查周期。

锁释放时终止续期：

当调用 unlock() 释放锁时，会同时取消续期的定时任务，避免无限续期。

LeetCode Hot 100 - 24. 两两交换链表中的节点

2025-11-11T07:00:00.000Z

LeetCode 24. 两两交换链表中的节点

题目大意

给定一个单链表，需要将链表中的节点按顺序两两交换，并返回交换后新的链表头节点。禁止只交换节点的数值，必须真实地调整指针。当链表长度为奇数时，最后一个节点保持原状。

示例

输入：head = [1,2,3,4]
输出：[2,1,4,3]

当输入为 head = [1,2,3] 时，结果应为 [2,1,3]，因为第三个节点无法参与交换。

代码实现

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(0, head);//初始化 0->1->2->3->4
        ListNode curr = dummy.next;
        ListNode node0 = dummy;
        ListNode node1 = curr;
      
        while (node1 != null && node1.next != null) {//至少为两个节点
            ListNode node2 = node1.next;
            ListNode node3 = node2.next;

            node0.next = node2;//0->2
            node1.next = node3;//1->3
            node2.next = node1;//2->1

            node0 = node1;//交换 在下一次的循环中1就是0
            node1 = node3;//3就是1
        }

        return dummy.next;
    }
}

Redis的数据过期淘汰策略

2025-10-27T11:17:00.000Z

Redis 的数据过期策略

Redis 采用 「惰性删除 + 定期删除」 两种策略相结合的方式，在 CPU 性能开销 与 内存占用 之间取得平衡。

一、惰性删除（Lazy Expiration）

当客户端访问或修改某个键时，Redis 会在操作前调用 expireIfNeeded() 函数检查该键是否已过期：

若已过期：
Redis 会立即删除该键，然后向客户端返回 null。
删除方式由配置项 lazyfree-lazy-expire 决定：
- 若开启（yes），则采用 异步删除；
- 若关闭（no），则采用 同步删除。
若未过期：
直接返回该键对应的正常值，不做任何额外处理。

这种方式的优点是 删除时机精准、不会浪费 CPU 时间；
缺点是：若某些过期键一直未被访问，就无法被清除，会长期占用内存。

二、定期删除（Active Expiration Cycle）

为了解决惰性删除的不足，Redis 还会周期性地扫描部分键空间，清除已过期的数据。

1. 检查频率

Redis 默认每秒执行 10 次过期扫描，这一频率由配置文件 redis.conf 中的参数 hz 控制：

hz 10

即 Redis 每隔约 100 毫秒 触发一次过期检测。

2. 检查机制

Redis 并不会遍历所有键，而是采用「随机抽查」机制来控制 CPU 占用。
该逻辑由 expire.c 文件中的 activeExpireCycle() 函数实现，核心过程如下：

从每个数据库的「过期字典」中 随机抽取 20 个 key（数量由常量 ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP = 20 决定）；
检查这 20 个 key 是否过期，并删除已过期的 key；
如果本轮抽查中，超过 25%（即 5 个）键过期，说明系统中可能仍存在大量过期数据，Redis 会继续重复步骤 1，进行新一轮检查；
若过期比例低于 25%，则认为当前负载正常，Redis 会停止本轮扫描，等待下一次周期执行。

介绍一下Redis 内存淘汰策略

在 32 位操作系统中，maxmemory 的默认值是 3G，因为 32 位的机器最大只支持 4GB 的内存，而系统本身就需要一定的内存资源来支持运行，所以 32 位操作系统限制最大 3 GB 的可用内存是非常合理的，这样可以避免因为内存不足而导致 Redis 实例崩溃。

1、不进行数据淘汰的策略：

noeviction（Redis3.0之后，默认的内存淘汰策略）：它表示当运行内存超过最大设置内存时，不淘汰任何数据，这时如果有新的数据写入，会报错通知禁止写入，不淘汰任何数据，但是如果没用数据写入的话，只是单纯的查询或者删除操作的话，还是可以正常工作。

2、进行数据淘汰的策略：

针对「进行数据淘汰」这一类策略，又可以细分为「在设置了过期时间的数据中进行淘汰」和「在所有数据范围内进行淘汰」这两类策略。

在设置了过期时间的数据中进行淘汰：
- volatile-random：随机淘汰设置了过期时间的任意键值；
- volatile-ttl：优先淘汰更早过期的键值。
- volatile-lru（Redis3.0 之前，默认的内存淘汰策略）：淘汰所有设置了过期时间的键值中，最久未使用的键值；
- volatile-lfu（Redis 4.0 后新增的内存淘汰策略）：淘汰所有设置了过期时间的键值中，最少使用的键值；
在所有数据范围内进行淘汰：
- allkeys-random：随机淘汰任意键值;
- allkeys-lru：淘汰整个键值中最久未使用的键值；
- allkeys-lfu（Redis 4.0 后新增的内存淘汰策略）：淘汰整个键值中最少使用的键值。

缓存穿透，雪崩，击穿

2025-10-25T09:13:00.000Z

缓存穿透

缓存穿透指的是：一个缓存和数据库中都不存在的数据，由于数据库无法写入缓存，导致频繁请求直接打到数据库，从而造成数据库压力过大甚至被“打穿”。

常见的解决方法包括：缓存空值 或 布隆过滤器。

布隆过滤器由一个全 0 的位图数组和 n 个哈希函数组成。当一个数据在请求缓存前，会先经过布隆过滤器。过滤器会通过 n 个哈希函数计算出 n 个哈希值，再分别对数组长度取模，并将对应的数组下标置为 1。

查询时，只需要查看位图数组中这 n 个位置是否全部为 1：

若存在某个位为 0，则说明该数据一定不存在于数据库中；
若全部为 1，则说明该数据可能存在，但不一定真的存在，因为可能出现哈希碰撞。

因此，布隆过滤器判断“存在”时并不能保证数据真的存在，但判断“不存在”时一定准确。

缓存雪崩

缓存雪崩指的是：大量的缓存 Key 在同一时间失效，或者 Redis 服务器宕机，导致所有请求同时打到数据库，造成数据库瞬时压力过大，甚至宕机的情况。

解决方法：
为缓存设置 固定过期时间 + 随机过期时间，让不同 Key 的过期时间错开，避免在同一时间集中失效。

缓存击穿

缓存击穿指的是一个热点key设置了时间了过后时间过期了恰好这个时候大量请求打到数据库让数据库压力大

解决方案：

方案一：互斥锁（分布式锁）

当缓存失效时，不立即去加载数据库，而是先使用 Redis 的 SETNX 命令设置互斥锁。

若设置成功（即当前线程获得锁），则执行 load db 操作并回填缓存；
若设置失败（说明已有线程在加载数据），则稍后重试获取缓存。

优点：保证数据一致性。
缺点：性能稍差，可能存在死锁风险。

方案二：逻辑过期

设置 Key 时，不给 Redis 设置真实的过期时间，而是在 Value 中自带一个逻辑过期时间字段。
实现思路如下：

设置缓存时，将过期时间作为字段与数据一起存入；
查询时，先从 Redis 获取数据并判断逻辑时间是否过期；
若已过期，则异步开启一个线程进行数据刷新，同时返回旧数据给用户（保证高可用）。

优点：高性能、高可用。
缺点：数据可能短时间内不一致。

总结：

若追求强一致性 → 使用 分布式锁方案；
若追求高性能、高可用性 → 使用 逻辑过期方案。

【模板】P1439 最长公共子序列

2025-05-09T15:26:33.000Z

P1439 【模板】最长公共子序列（洛谷题面）

题目

题目描述：

给出的两个排列和，求它们的最长公共子序列。

输入格式：

第一行是一个数。

接下来两行，每行为个数，为自然数的一个排列。

输出格式：

一个数，即最长公共子序列的长度。

数据范围与说明：

对于的数据，；
对于的数据，。

输入输出样例 #1

输入：

1
2
3

5 
3 2 1 4 5
1 2 3 4 5

输出：

题意

给定的两个排列、，求它们的最长公共子序列（LCS）长度。

思路

经典做法是动态规划，但对于的数据会超时。利用“两个序列都是排列”的性质，可以将 LCS 转化为 LIS（最长上升子序列）：

建立哈希（或数组）mp[val] 记录值 val 在序列中的位置；
遍历，将 $P_2[i]在 $P_1$ 中的位置mp[P2[i]]` 依次写入新数组；
问题就变成了：求该新数组的 LIS 长度，使用 lower_bound + 贪心即可达到。

复杂度：时间，空间。

代码

#include 
using namespace std;

const int N = 100000 + 5;
int pos[N], b[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        int v; cin >> v;
        pos[v] = i;
    }
    for (int i = 1; i <= n; ++i) cin >> b[i];

    vector<int> lis;
    lis.reserve(n);
    for (int i = 1; i <= n; ++i) {
        int mapped = pos[b[i]];
        auto it = lower_bound(lis.begin(), lis.end(), mapped);
        if (it == lis.end()) lis.push_back(mapped);
        else *it = mapped;
    }
    cout << lis.size() << '\n';
    return 0;
}

【题解】P1434 [SHOI2002] 滑雪

2025-03-24T10:30:14.000Z

P1434 [SHOI2002] 滑雪（洛谷题面）

题目

题目描述：

Michael 喜欢滑雪。这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael 想知道在一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子：

1   2   3   4   5
16  17  18  19  6
15  24  25  20  7
14  23  22  21  8
13  12  11  10  9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度会减小。在上面的例子中，一条可行的滑坡为 $24-17-16-1$ （从 $24$ 开始，在 $1$ 结束）。当然 $25$ － $24$ － $23$ － $\ldots$ － $3$ － $2$ － $1$ 更长。事实上，这是最长的一条。

输入格式：

输入的第一行为表示区域的二维数组的行数 $R$ 和列数 $C$ 。下面是 $R$ 行，每行有 $C$ 个数，代表高度（两个数字之间用 $1$ 个空格间隔）。

输出格式：

输出区域中最长滑坡的长度。

数据范围与说明：

对于 $100\%$ 的数据， $1\leq R,C\leq 100$ 。

输入输出样例 #1

输入：

5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

输出：

代码

#include 
using namespace std;
typedef long long ll;
int a[105][105];
int dp[105][105];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int n, m;
bool check(int i, int j) {
    return i >= 0 && i < n && j >= 0 && j < m;
}
int dfs(int i, int j) {
    if (dp[i][j] != 0) return dp[i][j];
    dp[i][j] = 1;
    for (int z = 0; z < 4; z++) {
        int x = i + dx[z], y = j + dy[z];
        if (check(x, y) && a[x][y] < a[i][j]) {
            dp[i][j] = max(dp[i][j], 1 + dfs(x, y));
        }
    }
    return dp[i][j];
}
void solve() {
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> a[i][j];
        }
    }
    int ans = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            ans = max(ans, dfs(i, j));
        }
    }
    cout << ans << "\n";
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    solve();
    return 0;
}

【深基9.例4】求第 k 小的数 - 题解

2025-03-23T13:41:45.000Z

P1923 【深基9.例4】求第 k 小的数（洛谷题面）

题目

题目描述：

输入 $n$ （ $1 \le n < 5000000$ 且 $n$ 为奇数）个数字 $a_i$ （ $1 \le a_i < {10}^9$ ），输出这些数字的第 $k$ 小的数。最小的数是第 $0$ 小。

请尽量不要使用 nth_element 来写本题，因为本题的重点在于练习分治算法。

输入格式：

第一行有两个整数，分别表示 $n$ 和 $k$ 。

第二行有 $n$ 个整数，第 $i$ 个数表示 $a_i$ 。

输出格式：

一个整数，表示第 $k$ 小的数。

数据范围与说明：

输入输出样例 #1

输入：

1 2	5 1 4 3 2 1 5

输出：

代码

#include 
using namespace std;
typedef long long ll;
typedef pair<int, int> PLL;
int a[5000005];
int n,k;
void qsort(int i,int j){
    int l=i,r=j,mid=a[(l+r)/2];
    while(l<=r){
        while(a[r]>mid){
            r--;
        }
        while(a[l]
            l++;
        }
        if(l<=r){
            swap(a[l],a[r]);
            r--;
            l++;
        }
    }
    if(k<=r){
        qsort(i,l);
    }else if(l<=k){
        qsort(r,j);
    }else{
        cout<+1];
        return ;
    }
}
void solve() {
    cin>>n>>k;
    for(int i=0;i
        cin>>a[i];
    }
    qsort(0,n-1);
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    while (t--) {
        solve();
    }
    return 0;
}

【题解】P2196

2025-03-22T14:27:43.000Z

P2196

题目

题目描述：

在一个地图上有 $N\ (N \le 20)$ 个地窖，每个地窖中埋有一定数量的地雷。同时，给出地窖之间的连接路径。当地窖及其连接的数据给出之后，某人可以从任一处开始挖地雷，然后每次可以移动到一个编号比当前节点大且联通的节点去挖地雷，当无满足条件的节点时挖地雷工作结束。设计一个挖地雷的方案，使某人能挖到最多的地雷。

输入格式：

有若干行。

第 $1$ 行只有一个数字，表示地窖的个数 $N$ 。

第 $2$ 行有 $N$ 个数，分别表示每个地窖中的地雷个数。

第 $3$ 行至第 $N+1$ 行表示地窖之间的连接情况：

第 $3$ 行有 $n-1$ 个数（ $0$ 或 $1$ ），表示第一个地窖至第 $2$ 个、第 $3$ 个 $\dots$ 第 $n$ 个地窖有否路径连接。如第 $3$ 行为 $1\space 1\space 0\space 0\space 0\cdots 0$ ，则表示第 $1$ 个地窖至第 $2$ 个地窖有路径，至第 $3$ 个地窖有路径，至第 $4$ 个地窖、第 $5$ 个 $\dots$ 第 $n$ 个地窖没有路径。

第 $4$ 行有 $n-2$ 个数，表示第二个地窖至第 $3$ 个、第 $4$ 个 $\dots$ 第 $n$ 个地窖有否路径连接。

……

第 $n+1$ 行有 $1$ 个数，表示第 $n-1$ 个地窖至第 $n$ 个地窖有否路径连接。（为 $0$ 表示没有路径，为 $1$ 表示有路径）。

输出格式：

第一行表示挖得最多地雷时的挖地雷的顺序，各地窖序号间以一个空格分隔，不得有多余的空格。

第二行只有一个数，表示能挖到的最多地雷数。

数据范围与说明：

【样例解释】

最优路径为 $1 \to 3 \to 4 \to 5$ ，结果为 $27$ 。

【题目来源】

NOIP 1996 提高组第三题。

输入输出样例 #1

输入：

输出：

1 2	1 3 4 5 27

代码

#include
using namespace std;
int n,ans,f[25][25],a[25],b[25];
vector<int> path,ans_path;
bool check(int x){
    for(int i=1;i<=n;i++){
        if(f[x][i]&&!b[i])  return false;
    }
    return true;
}
void dfs(int x,int sum){
    if(check(x)){
        if(ans
            ans=sum;
            ans_path=path;
        }
        return ;
    }
    for(int i=1;i<=n;i++){
        if(f[x][i]&&!b[i]){
            b[i]=1;
            path.push_back(i);
            dfs(i,sum+a[i]);
            path.pop_back();
            b[i]=0;
        }
    }
    return ;
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    for(int i=1;i
        for(int j=i+1;j<=n;j++){
            cin>>f[i][j];
        }
    }
    for(int i=1;i<=n;i++){
        b[i]=1;
        path.clear();
        path.push_back(i);
        dfs(i,a[i]);
        b[i]=0;
    }
    for(int x:ans_path){
        cout<" ";
    }
    cout<<"\n";
    cout<
    return 0;
}

【题解】P1216 [IOI 1994 / USACO1.5] 数字三角形

2025-03-22T10:04:36.000Z

P1216 [IOI 1994 / USACO1.5] 数字三角形（洛谷题面）

题目

题目描述：

观察下面的数字金字塔。

写一个程序来查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以走到左下方的点也可以到达右下方的点。

在上面的样例中，从 $7 \to 3 \to 8 \to 7 \to 5$ 的路径产生了最大权值。

输入格式：

第一个行一个正整数 $r$ ，表示行的数目。

后面每行为这个数字金字塔特定行包含的整数。

输出格式：

单独的一行，包含那个可能得到的最大的和。

数据范围与说明：

【数据范围】
对于 $100\%$ 的数据， $1\le r\le 1000$ ，所有输入在 $[0,100]$ 范围内。

题目翻译来自 NOCOW。

IOI1994 Day1T1 / USACO Training Section 1.5。

输入输出样例 #1

输入：

输出：

代码

#include
using namespace std;
int a[1010][1010],f[1010][1010];
int main(){
int n,s=0;
cin>>n;
for(int i=1;i<=n;i++)
for(int j=1;j<=i;j++)
cin>>a[i][j];
for(int i=1;i<=n;i++)
for(int j=1;j<=i;j++)
f[i][j]=max(f[i-1][j-1],f[i-1][j])+a[i][j];
for(int j=1;j<=n;j++) s=max(s,f[n][j]);
cout<
return 0;
}

【题解】P3654

2025-03-19T14:03:00.000Z

P3654

题目

题目描述：

可是……这个篮球场，好像很久没有使用过的样子啊……

里面堆满了学校的各种杂物呢……

我们 Aqours 的成员要怎么在里面列队站下呢？

我们浦之星女子学院的篮球场是一个 $R$ 行 $C$ 列的矩阵，其中堆满了各种学校的杂物 (用 # 表示)，空地 (用 . 表示) 好像并不多的样子呢……

我们 Aqours 现在已经一共有 $K$ 个队员了，要歌唱舞蹈起来的话，我们得排成一条 $1\times K$ 的直线，一个接一个地站在篮球场的空地上呢 (横竖均可)。

我们想知道一共有多少种可行的站位方式呢。

Aqours 的真正的粉丝的你，能帮我们算算吗？

输入格式：

第一行三个整数 $R, C, K$ 。

接下来的 $R$ 行 $C$ 列，表示浦之星女子学院篮球场。

输出格式：

总共的站位方式数量。

数据范围与说明：

	$R$	$C$	$K$	备注
$1\sim2$	$\leq 10$	$\leq 10$	$\leq \min(R,C)$	无
$3\sim4$	$\leq 100$	$\leq 100$	$\leq 1$	无
$5\sim6$	$\leq 100$	$\leq 100$	$\leq \min(R,C)$	没有障碍
$7\sim10$	$\leq 100$	$\leq 100$	$\leq \min(R,C)$	无

对于所有数据， $1 \leq R,C \leq 100$ ， $1 \leq k \leq \min(R,C)$ 。

以下是彩蛋

在 LoveLive!Sunshine!! 动画第一季第三集中，Aqours 队长高海千歌演唱“最喜欢的话就没问题！”到副歌前时，学校因为雷击停电。

输入输出样例 #1

输入：

5 5 2
.###.
##.#.
..#..
#..#.
#.###

输出：

代码

#include
using namespace std;
char a[105][105];
int r,c,k;
long long ans;
bool check(int i,int j){
    return i>=0&&i=0&&j
}
void dfsr(int i,int j,int cnt){
    if(cnt==k){
        ans++;
        return ;
    }
    if(!check(i,j)) return ;
    if(a[i][j+1]=='.'){
        dfsr(i,j+1,cnt+1);
    }
    return ;
}
void dfsu(int i,int j,int cnt){
    if(cnt==k){
        ans++;
        return ;
    }
    if(!check(i,j)) return ;
    if(a[i+1][j]=='.'){
        dfsu(i+1,j,cnt+1);
    }
    return ;
}
int main(){
    cin>>r>>c>>k;
    for(int i=0;i
        for(int j=0;j
            cin>>a[i][j];
        }
    }
    for(int i=0;i
        for(int j=0;j
            if(a[i][j]=='.'){
                dfsr(i,j,1);
                dfsu(i,j,1);
            }
        }
    }
    if(k==1){
        cout<2;
    }else{
        cout<
    }
    return 0;
}

【题解】P10415

2025-03-19T06:26:43.000Z

P10415（洛谷题面）

题目

题目描述：

给定一个 $W\times H$ 的长方形，两边长度均为整数。小蓝想把它切割为很多个边长为整数的小正方形。假设切割没有任何损耗，正方形的边长至少为 $2$ ，不允许出现余料，要求所有正方形的大小相等，请问最多能切割出多少个?

输入格式：

输入一行，包含两个整数 $W, H$ ，用一个空格分隔。

输出格式：

输出一行包含一个整数表示答案。如果不存在满足要求的方案，输出 $0$ 。

数据范围与说明：

【样例解释 1】

切割成 $5\times 10=50$ 个边长为 $2$ 的正方形。

【评测用例规模与约定】

对于 $30\%$ 的评测用例， $1\le W,H\le 1000$ ；
对于 $60\%$ 的评测用例， $1\le W,H\le 10^6$ ；
对于所有评测用例， $1\le W,H\le 10^9$ 。

输入输出样例 #1

输入：

10 20

输出：

输入输出样例 #2

输入：

6 9

输出：

输入输出样例 #3

输入：

8 13

输出：

题意

简述：

代码

C++

#include 
using namespace std;
const int N=1e6+10;
typedef long long ll;
typedef pair<int, int> PLL;
int gcd(int a,int b){
    return b? gcd(b,a%b):a;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    // cin >> t;
    ll n,m;
   cin>>n>>m;
    int w=gcd(n,m);//最大正方形的边长
    if(w==1){//如果两个都是质数那么不能完全分解
        cout<<0;
        return 0;
    }
    for(int i=2;i*i<=w;i++){//最大公约数便是最大正方形的面积，因此用i*i来比较 
        if(n%i==0&&m%i==0){
            cout<
            return 0;
        }
    }
    cout<//特判w是质数的情况
    return 0;
}

【题解】P1048 [NOIP 2005 普及组] 采药

2025-03-18T14:41:33.000Z

P1048 [NOIP 2005 普及组] 采药（洛谷题面）

题目

题目描述：

辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

如果你是辰辰，你能完成这个任务吗？

输入格式：

第一行有 $2$ 个整数 $T$ （ $1 \le T \le 1000$ ）和 $M$ （ $1 \le M \le 100$ ），用一个空格隔开， $T$ 代表总共能够用来采药的时间， $M$ 代表山洞里的草药的数目。

接下来的 $M$ 行每行包括两个在 $1$ 到 $100$ 之间（包括 $1$ 和 $100$ ）的整数，分别表示采摘某株草药的时间和这株草药的价值。

输出格式：

输出在规定的时间内可以采到的草药的最大总价值。

数据范围与说明：

【数据范围】

对于 $30\%$ 的数据， $M \le 10$ ；
对于全部的数据， $M \le 100$ 。

【题目来源】

NOIP 2005 普及组第三题

输入输出样例 #1

输入：

输出：

题意

简述：

如果你是辰辰，你能完成这个任务吗？

代码

C++

#include 
using namespace std;

typedef long long ll;
typedef pair<int, int> PLL;
int m,v[1005],w[1005];
int dp[1005][1005];
int t = 1;
void solve() {
    cin >> t>>m;
    for(int i=1;i<=m;i++){
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=m;i++){
        for(int j=t;j>0;j--){
            if(j
                dp[i][j]=dp[i-1][j];
            }else{
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);
            }
        }
    }
    cout<
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    
    solve();
    return 0;
}

【题解】P2347

2025-03-18T14:31:37.000Z

P2347（洛谷题面）

题目

题目描述：

设有 $1\mathrm{g}$ 、 $2\mathrm{g}$ 、 $3\mathrm{g}$ 、 $5\mathrm{g}$ 、 $10\mathrm{g}$ 、 $20\mathrm{g}$ 的砝码各若干枚（其总重），可以表示成多少种重量？

输入格式：

输入方式： $a_1 , a_2 ,a_3 , a_4 , a_5 ,a_6$

（表示 $1\mathrm{g}$ 砝码有 $a_1$ 个， $2\mathrm{g}$ 砝码有 $a_2$ 个， $\dots$ ， $20\mathrm{g}$ 砝码有 $a_6$ 个）

输出格式：

输出方式：Total=N

（ $N$ 表示用这些砝码能称出的不同重量的个数，但不包括一个砝码也不用的情况）

数据范围与说明：

【题目来源】

NOIP 1996 提高组第四题

输入输出样例 #1

输入：

1	1 1 0 0 0 0

输出：

Total=3

代码

#include
using namespace std;
int a[]={1,2,3,5,10,20};
int b[300];
int dp[1100];
int main(){
    int sum=0;
    for(int i=0;i<6;i++){
        cin>>b[i];
        sum+=a[i]*b[i];
    }
    int ans=0;
    dp[0] = 1;
    for(int i=0;i<6;i++){
        for(int j=sum;j>=0;j--){
            for (int k = 1; k <= b[i]; k++){ 
if (dp[j - a[i]*k] == 1 && j - a[i]*k >= 0 && dp[j] == 0){
                    dp[j] = 1,ans++;
                }
}
        }
    }
    cout<<"Total="<
    return 0;
}

【题解】P8195

2025-03-15T08:31:26.000Z

P8195

题目

题目描述：

传智专修学院给了小智一个仅包含小写字母的字符串 $s$ ，他想知道，里面出现了多少次子串 chuanzhi 呢。

我们称一个字符串 $t$ 是 $s$ 的子串，当且仅当将 $s$ 的开头若干个（可以为 0 个）连续字符和结尾若干个（可以为 0 个）连续字符删去后，剩下的字符串和 $t$ 相同。例如，我们称 ab 是 abc 的子串，但 ac 不是 abc 的子串。

输入格式：

输入只有一行一个字符串，表示字符串 $s$ 。

输出格式：

输出一行一个整数表示答案。

数据范围与说明：

数据规模与约定

对于全部的测试点，保证 $1 \leq |s| \leq 4 \times 10^5$ ， $|s|$ 表示 $s$ 的长度，且 $s$ 中只有小写字母。

输入输出样例 #1

输入：

1	welcometochuanzhicupchuanzhi

输出：

代码

#include
using namespace std;
int main() {
    string s;
    cin >> s;
    string target = "chuanzhi";
    int index = 0, count = 0;
    for (char c : s) {
        if (c == target[index]) {
            index++;
            if (index == 8) {
                count++;
                index = 0;
            }
        } else {
            index = (c == target[0]) ? 1 : 0;
        }
    }
    cout << count;
    return 0;
}

【题解】P8196

2025-03-15T08:06:58.000Z

P8196（洛谷题面）

题目

题目描述：

给定一个长度为 $n$ 的数列 $a$ ，对于一个有序整数三元组 $(i, j, k)$ ，若其满足 $1 \leq i \leq j \leq k \leq n$ 并且 $a_i +a_j = a_k$ ，则我们称这个三元组是「传智的」。

现在请你计算，有多少有序整数三元组是传智的。

输入格式：

本题单测试点内有多组测试数据。

输入的第一行是一个整数 $T$ ，表示数据组数。

对于每组数据：

第一行是一个整数，表示数列的长度 $n$ 。
第二行有 $n$ 个整数，第 $i$ 个整数表示 $a_i$ 。

输出格式：

对于每组数据，输出一行一个整数表示答案。

数据范围与说明：

样例 1 解释

对于第一组数据，因为 $a_1 + a_1 = a_2$ ， $a_1 + a_2 = a_3$ ，故共 $(1, 1, 2)$ 和 $(1, 2, 3)$ 两个三元组。
对于第二组数据六个三元组分别是：

$(1, 1, 2)$
$(1, 2, 3)$
$(1, 3, 4)$
$(1, 4, 5)$
$(2, 2, 4)$
$(2, 3, 5)$

数据规模与约定

对于全部测试点，保证 $1 \leq T \leq 100$ ， $1 \leq n , a_i \leq 100$ ，且各个测试点的 $n$ 之和不超过 $100$ ，即 $\sum n \leq 100$ 。

输入输出样例 #1

输入：

输出：

1
2

2
6

代码

#include 
using namespace std;
typedef long long ll;
typedef pair<int, int> PLL;
int a[105];
void solve() {
    int n,cnt=0;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    for(int i=1;i<=n;i++){
        for(int j=i;j<=n;j++){
            for(int k=j;k<=n;k++){
                if(a[i]+a[j]==a[k]){
                    cnt++;
                }
            }
        }
    }
    cout<
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

口算练习题 - 题解

2025-03-13T08:56:10.000Z

口算练习题（洛谷题面）

题目

题目描述：

王老师正在教简单算术运算。细心的王老师收集了 $i$ 道学生经常做错的口算题，并且想整理编写成一份练习。编排这些题目是一件繁琐的事情，为此他想用计算机程序来提高工作效率。王老师希望尽量减少输入的工作量，比如 $\texttt{5+8}$ 的算式最好只要输入 $\texttt 5$ 和 $\texttt 8$ ，输出的结果要尽量详细以方便后期排版的使用，比如对于上述输入进行处理后输出 $\texttt{5+8=13}$ 以及该算式的总长度 $6$ 。王老师把这个光荣的任务交给你，请你帮他编程实现以上功能。

输入格式：

第一行一个整数 $i$ 。

接着的 $i$ 行为需要输入的算式，每行可能有三个数据或两个数据。

若该行为三个数据则第一个数据表示运算类型， $\texttt a$ 表示加法运算， $\texttt b$ 表示减法运算， $\texttt c$ 表示乘法运算，接着的两个数据表示参加运算的运算数。

若该行为两个数据，则表示本题的运算类型与上一题的运算类型相同，而这两个数据为运算数。

输出格式：

输出 $2\times i$ 行。对于每个输入的算式，输出完整的运算式及结果，第二行输出该运算式的总长度。

数据范围与说明：

【数据规模与约定】

对于 $50\%$ 的数据，输入的算式都有三个数据。

对于所有数据， $0$ ，第一个算式一定有三个数据，运算数为非负整数且小于 $10000$ 。

输入输出样例 #1

输入：

输出：

64+46=110
9
275+125=400
11
11*99=1089
10
46-64=-18
9

代码

#include
using namespace std;
int main(){
    char c;
    int n,a,b;
    cin>>n;
    string s;
    for(int i=0;i
        cin>>s;
        if(s[0]>='a'&&s[0]<='c'){
            c=s[0];
            cin>>a>>b;
        }else{
            a=stoi(s);
            cin>>b;
        }
       if(c=='a'){
           string ans=to_string(a)+"+"+to_string(b)+"="+to_string(a+b);
           cout<
           cout<size()<
       }else if(c=='b'){
           string ans=to_string(a)+"-"+to_string(b)+"="+to_string(a-b);
           cout<
           cout<size()<
       }else if(c=='c'){
           string ans=to_string(a)+"*"+to_string(b)+"="+to_string(a*b);
           cout<
           cout<size()<
       }
    }
    return 0;
}

【题解】P10900

2025-03-13T07:04:51.000Z

P10900（洛谷题面）

题目

题目描述：

在诗人的眼中，数字是生活的韵律，也是诗意的表达。

小蓝，当代顶级诗人与数学家，被赋予了“数学诗人” 的美誉。他擅长将冰冷的数字与抽象的诗意相融合，并用优雅的文字将数学之美展现于纸上。

某日，小蓝静坐书桌前，目光所及，展现着 $n$ 个数字，它们依次为 $a_1, a_2, \cdots, a_n$ ，熠熠生辉。小蓝悟到，如果一个数能够以若干个（至少两个）连续的正整数相加表示，那么它就蕴含诗意。例如，数字 $6$ 就蕴含诗意，因为
它可以表示为 $1 + 2 + 3$ 。而 $8$ 则缺乏诗意，因为它无法用连续的正整数相加表示。

小蓝希望他面前的所有数字都蕴含诗意，为此，他决定从这 $n$ 个数字中删除一部分。请问，小蓝需要删除多少个数字，才能使剩下的数字全部蕴含诗意？

输入格式：

输入的第一行包含一个整数 $n$ ，表示展示的数字个数。

第二行包含 $n$ 个整数 $a_1, a_2, \cdots, a_n$ ，相邻整数之间使用一个空格分隔，表示展示的数字。

输出格式：

输出一行包含一个整数，表示小蓝需要删除的数字个数，以使剩下的数字全部蕴含诗意。

数据范围与说明：

【样例说明】

在样例中，数字 $3$ 可以表示为 $1 + 2$ ，数字 $6$ 可以表示为 $1 + 2 + 3$ ，数字 $8$ 无法表示为连续的正整数相加，因此，需要删除的数字个数为 $1$ 。

【评测用例规模与约定】

对于 $30\%$ 的评测用例， $1 \le n \le 10^3$ ， $1 \le a_i \le 10^3$ 。
对于所有评测用例， $1 \le n \le 2 \times 10^5$ ， $1 \le a_i \le 10^{16}$ 。

输入输出样例 #1

输入：

1
2

3
3 6 8

输出：

题意

简述：

在诗人的眼中，数字是生活的韵律，也是诗意的表达。

小蓝，当代顶级诗人与数学家，被赋予了“数学诗人” 的美誉。他擅长将冰冷的数字与抽象的诗意相融合，并用优雅的文字将数学之美展现于纸上。

代码

C++

#include
using namespace std;
typedef long long ll;
const int N=2e5+10;
ll a[N];
bool check(ll n){
    return n&(n-1);
}

int main(){
    ll n;
    cin>>n;
    for(int i=0;i>a[i];
    ll ans=0;
    for(int i=0;i
        if(!check(a[i])){
            ans++;
        }
    }
    cout<
    return 0;
}

【题解】P5638

2025-03-12T17:55:35.000Z

P5638

题目

题目描述：

小 K 打下的江山一共有 $n$ 个城市，城市 $i$ 和城市 $i+1$ 有一条双向高速公路连接，走这条路要耗费时间 $a_i$ 。

小 K 为了关心人民生活，决定定期进行走访。他每一次会从 $1$ 号城市到 $n$ 号城市并在经过的城市进行访问。其中终点必须为城市 $n$ 。

不仅如此，他还有一个传送器，传送半径为 $k$ ，也就是可以传送到 $i-k$ 和 $i+k$ 。如果目标城市编号小于 $1$ 则为 $1$ ，大于 $n$ 则为 $n$ 。

但是他的传送器电量不足，只能传送一次，况且由于一些原因，他想尽量快的完成访问，于是就想问交通部部长您最快的时间是多少。

注意：他可以不访问所有的城市，使用传送器不耗费时间。

输入格式：

两行，第一行两个正整数 $n,k$ 。

第二行 $n-1$ 个整数，第 $i$ 个表示 $a_i$ 。

输出格式：

一个整数，表示答案。

数据范围与说明：

样例解释 1：

样例 1,2 的图示均为以下图片：

不使用传送器直接走，答案为 $6$ ，可以证明这个是最小值。

样例解释 2：

在 $3$ 处使用，传送到 $4$ ，答案为 $3$ ，可以证明这个是最小值。

数据范围：

对于所有数据， $n\ge 2$ ， $k\ge 1$ ， $a_i > 0$ 。

测试点编号	$n$ 的范围	$k$ 的范围	$a_i$ 的范围
$1\sim 10$	$\le 100$	$\le 100$	$\le 10^5$
$11\sim 20$	$\le 3\times 10^3$	$\le 3\times 10^3$	$\le 10^9$
$21$	$\le 10^5$	$\le 10^5$	$\le 10^{12}$
$22$	$\le 2\times 10^5$	$\le 2\times 10^5$	$\le 10^{12}$
$23$	$\le 5\times 10^5$	$\le 5\times 10^5$	$\le 10^{12}$
$24\sim 25$	$\le 10^6$	$\le 10^6$	$\le 10^{12}$

输入输出样例 #1

输入：

1
2

4 0
1 2 3

输出：

输入输出样例 #2

输入：

1
2

4 1
1 2 3

输出：

代码

#include
using namespace std;
typedef long long ll;
const int N=1e6+10;
ll a[N],s[N];
int main(){
    ll n,k;
    cin>>n>>k;
    if(k+1>=n){
        cout<<0;
        return 0;
    }
    for(int i=1;i<=n-1;i++){
        cin>>a[i];
        s[i]=s[i-1]+a[i];
    }
    ll ans=LLONG_MAX;
    for(int i=1;i<=n-k;i++){
        ll sum = s[i + k - 1] - s[i - 1];
        ans=min(ans,s[n-1]-sum);
    }
    cout<
    return 0;
}

【题解】P1143 进制转换

2025-03-09T11:13:37.000Z

P1143 进制转换（洛谷题面）

题目

题目描述：

请你编一程序实现两种不同进制之间的数据转换。

输入格式：

共三行，第一行是一个正整数，表示需要转换的数的进制 $n\ (2\le n\le 16)$ ，第二行是一个 $n$ 进制数，若 $n>10$ 则用大写字母 $\verb!A!\sim \verb!F!$ 表示数码 $10\sim 15$ ，并且该 $n$ 进制数对应的十进制的值不超过 $10^9$ ，第三行也是一个正整数，表示转换之后的数的进制 $m\ (2\le m\le 16)$ 。

输出格式：

一个正整数，表示转换之后的 $m$ 进制数。

数据范围与说明：

输入输出样例 #1

输入：

1
2
3

16
FF
2

输出：

11111111

代码

#include 
using namespace std;
int main(){
    int n,m,num=0;
    string s;
    cin>>n;
    cin>>s;
    cin>>m;
    reverse(s.begin(),s.end());
    for(int i=0;isize();i++){
        if(s[i]>='A'&&s[i]<='F'){
            num+=(s[i]-55)*pow(n,i);
        }else{
            num+=(s[i]-'0')*pow(n,i);
        }
    }
    string ans;
    while(num){
        int tmp=num%m;
        if(tmp>10){
            ans.push_back(tmp+55);
        }else{
            ans.push_back(tmp+'0');
        }
        num/=m;
    }
    reverse(ans.begin(),ans.end());
    cout<
    return 0;
}

【题解】P1225

2025-03-06T12:51:34.000Z

P1225

题目

题目描述：

黑白棋游戏的棋盘由 $4 \times 4$ 方格阵列构成。棋盘的每一方格中放有 $1$ 枚棋子，共有 $8$ 枚白棋子和 $8$ 枚黑棋子。这 $16$ 枚棋子的每一种放置方案都构成一个游戏状态。在棋盘上拥有 $1$ 条公共边的 $2$ 个方格称为相邻方格。一个方格最多可有 $4$ 个相邻方格。在玩黑白棋游戏时，每一步可将任何 $2$ 个相邻方格中棋子互换位置。对于给定的初始游戏状态和目标游戏状态，编程计算从初始游戏状态变化到目标游戏状态的最短着棋序列。

输入格式：

输入文件共有 $8$ 行。前四行是初始游戏状态，后四行是目标游戏状态。每行 $4$ 个数分别表示该行放置的棋子颜色。“ $0$ ”表示白棋；“ $1$ ”表示黑棋。

输出格式：

输出文件的第一行是着棋步数 $n$ 。接下来 $n$ 行，每行 $4$ 个数分别表示该步交换棋子的两个相邻方格的位置。例如，abcd 表示将棋盘上 $(a,b)$ 处的棋子与 $(c,d)$ 处的棋子换位。

数据范围与说明：

由 @zhouyonglong 提供 SPJ

输入输出样例 #1

输入：

输出：

代码

#include
using namespace std;
int f[5005][5005],len=1;
void func(int x){
    for(int i=1;i<=len;i++){
        f[x][i]=f[x-1][i]+f[x-2][i];
    }
    for(int i=1;i<=len;i++){
        if(f[x][i]>=10){
            f[x][i+1]+=f[x][i]/10;
            f[x][i]%=10;
            while(f[x][len+1]){
                len++;
            }
        }
    }
}
int main(){
    int n;
    cin>>n;
    f[1][1]=1;
    f[2][1]=2;
    for(int i=3;i<=n;i++){
        func(i);
    }
    for(int i=len;i>=1;i--){
        cout<
    }
    return 0;
}

【题解】P1304 哥德巴赫猜想

2025-03-06T07:56:13.000Z

P1304 哥德巴赫猜想（洛谷题面）

题目

题目描述：

输入一个偶数 $N$ ，验证 $4\sim N$ 所有偶数是否符合哥德巴赫猜想：任一大于 $2$ 的偶数都可写成两个质数之和。如果一个数不止一种分法，则输出第一个加数相比其他分法最小的方案。例如 $10$ ， $10=3+7=5+5$ ，则 $10=5+5$ 是错误答案。

输入格式：

第一行输入一个正偶数 $N$

输出格式：

输出 $\dfrac{N-2}{2}$ 行。对于第 $i$ 行：

首先先输出正偶数 $2i+2$ ，然后输出等号，再输出加和为 $2i+2$ 且第一个加数最小的两个质数，以加号隔开。

数据范围与说明：

数据保证，。

输入输出样例 #1

输入：

输出：

4=2+2
6=3+3
8=3+5
10=3+7

代码

#include
using namespace std;
bool prime(int x){
    if(x<=1)  return false;
    for(int i=2;i<=sqrt(x);i++){
        if(x%i==0) return false;
    }
    return true;
}
int main(){
    int n;
    cin>>n;
    for(int i=4;i<=n;i+=2){
        for(int j=2;j
            if(prime(j)&&prime(i-j)){
                cout<"="<"+"<
                break;
            }
        }
    }
    return 0;
}

【题解】P1217 [USACO1.5] 回文质数

2025-03-05T16:13:44.000Z

P1217 [USACO1.5] 回文质数（洛谷题面）

题目

题目描述：

因为 $151$ 既是一个质数又是一个回文数（从左到右和从右到左是看一样的），所以 $151$ 是回文质数。

写一个程序来找出范围 $[a,b] (5 \le a < b \le 100,000,000)$ （一亿）间的所有回文质数。

输入格式：

第一行输入两个正整数 $a$ 和 $b$ 。

输出格式：

输出一个回文质数的列表，一行一个。

数据范围与说明：

Hint 1: Generate the palindromes and see if they are prime.

提示 1: 找出所有的回文数再判断它们是不是质数（素数）.

Hint 2: Generate palindromes by combining digits properly. You might need more than one of the loops like below.

提示 2: 要产生正确的回文数，你可能需要几个像下面这样的循环。

题目翻译来自NOCOW。

USACO Training Section 1.5

产生长度为 $5$ 的回文数：

for (d1 = 1; d1 <= 9; d1+=2) {    // 只有奇数才会是素数
     for (d2 = 0; d2 <= 9; d2++) {
         for (d3 = 0; d3 <= 9; d3++) {
           palindrome = 10000*d1 + 1000*d2 +100*d3 + 10*d2 + d1;//(处理回文数...)
         }
     }
 }

输入输出样例 #1

输入：

5 500

输出：

代码

#include
using namespace std;
int n,m;
bool prime(int x) {
    if (x < 2) return false;
    if (x == 2) return true;
    if (x % 2 == 0) return false;
    for (int i = 3; i * i <= x; i += 2) {
        if (x % i == 0) return false;
    }
    return true;
}
bool check(int x){
    string ans;
    int s=x;
    while(s){
        ans.push_back(s%10+'0');
        s/=10;
    }
    int l=0,r=ans.size()-1;
    while(l
        if(ans[l++]!=ans[r--]){
            return false;
        }
    }
    return true;
}
int main(){
    cin>>n>>m;
    if(m>=9999999) m=9999999;
if(n%2==0)n++;
    for(int i=n;i<=m;i++){
        if(check(i)&&prime(i)){
            cout<
        }
    }
    return 0;
}

【题解】P2543

2025-03-05T09:11:16.000Z

P2543

题目

题目描述：

输入格式：

输入文件中包含两个字符串X和Y。当中两字符串非0即1。序列长度均小于9999。

输出格式：

X和Y的最长公共子序列长度。

数据范围与说明：

输入输出样例 #1

输入：

1	01010101010 00000011111

输出：

输入输出样例 #2

输入：

1	01011 010010101111111111

输出：

代码

#include
using namespace std;
int dp[10001][10001];
int main(){
    string s1;
    string s2;
    int cnt=0;
    cin>>s1>>s2;
    for(int i=1;i<=s1.size();i++){
        for(int j=1;j<=s2.size();j++){
            if(s1[i-1]==s2[j-1])    dp[i][j]=dp[i-1][j-1]+1;
            else    dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
        }
    }
    cout<1.size()][s2.size()];
    return 0;
}

【题解】P10898

2025-03-03T09:22:29.000Z

P10898（洛谷题面）

题目

题目描述：

小蓝正在玩拼图游戏，他有 $7385137888721$ 个 $2 \times 2$ 的方块和 $10470245$ 个 $1 \times 1$ 的方块，他需要从中挑出一些来拼出一个正方形，比如用 $3$ 个 $2 \times 2$ 和 $4$ 个 $1 \times 1$ 的方块可以拼出一个 $4 \times 4$ 的正方形，用 $9$ 个 $2 \times 2$ 的方块可以拼出一个 $6 \times 6$ 的正方形，请问小蓝能拼成的最大的正方形的边长为多少。

输入格式：

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

输出格式：

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

数据范围与说明：

题意

简述：

代码

C++

#include
using namespace std;
int main(){
    long long t=7385137888721;
    long long o=10470245,n=0;
    for(long long i=o;i>=1;i--){
        if(i%4==0){
            n=i/4;
            break;
        }
    }
    t+=n;
    t=sqrt(t*4);
    cout<
    return 0;
}

【题解】P10426

2025-03-02T08:50:38.000Z

P10426（洛谷题面）

题目

题目描述：

在一个神秘的森林里，住着一个小精灵名叫小蓝。有一天，他偶然发现了一个隐藏在树洞里的宝藏，里面装满了闪烁着美丽光芒的宝石。这些宝石都有着不同的颜色和形状，但最引人注目的是它们各自独特的 “闪亮度” 属性。每颗宝石都有一个与生俱来的特殊能力，可以发出不同强度的闪光。小蓝共找到了 $n$ 枚宝石，第 $i$ 枚宝石的 “闪亮度” 属性值为 $H_i$ ，小蓝将会从这 $n$ 枚宝石中选出三枚进行组合，组合之后的精美程度 $S$ 可以用以下公式来衡量：

$S = H_a H_b H_c \cdot \frac{\operatorname{LCM}(H_a, H_b, H_c)}{\operatorname{LCM}(H_a, H_b) \cdot\operatorname{LCM}(H_a, H_c) \operatorname{LCM}(H_b, H_c)}$

其中 $\operatorname{LCM}$ 表示的是最小公倍数函数。

小蓝想要使得三枚宝石组合后的精美程度 $S$ 尽可能的高，请你帮他找出精美程度最高的方案。如果存在多个方案 $S$ 值相同，优先选择按照 $H$ 值升序排列后字典序最小的方案。

输入格式：

第一行一个整数 $n$ 表示宝石个数。
第二行有 $n$ 个整数 $H_1, H_2, \dots H_n$ 表示每个宝石的闪亮度。

输出格式：

输出一行包含三个整数表示满足条件的三枚宝石的 “闪亮度”。

数据范围与说明：

数据规模与约定

对 $30\%$ 的数据， $n \leq 100$ ， $H_i \leq 10^3$ 。
对 $60\%$ 的数据， $n \leq 2 \times 10^3$ 。
对全部的测试数据，保证 $3 \leq n \leq 10^5$ ， $1 \leq H_i \leq 10^5$ 。

输入输出样例 #1

输入：

1 2	5 1 2 3 4 9

输出：

1 2 3

题意

简述：

$S = H_a H_b H_c \cdot \frac{\operatorname{LCM}(H_a, H_b, H_c)}{\operatorname{LCM}(H_a, H_b) \cdot\operatorname{LCM}(H_a, H_c) \operatorname{LCM}(H_b, H_c)}$

其中 $\operatorname{LCM}$ 表示的是最小公倍数函数。

代码

C++

#include
using namespace std;
const int N=1e5+10;
int a[N],cnt[N];

int gcd(int a,int b){
    return b?gcd(b,a%b):a;
}

int lcm(int a,int b){
    return a*b/gcd(a,b);
}

int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        for(int j=1;j<=sqrt(a[i]);j++){
            if(a[i]%j==0){
                cnt[j]++;
                if(j!=sqrt(a[i]))   cnt[a[i]/j]++;
            }
        }
    }
    int x=1;
    for(int i=N-10;i>=1;i--){
        if(cnt[i]>=3){
            x=i;
            break;
        }
    }
    sort(a+1,a+n+1);
    
    int c=0;
    for(int i=1;i<=n;i++){
        if(a[i]%x==0){
            cout<" ";
            c++;
            if(c==3)    return 0;
        }
    }
    return 0;
}

【题解】P10425

2025-03-01T12:15:02.000Z

P10425（洛谷题面）

题目

题目描述：

小蓝最近在研究一种浮点数的表示方法： $R$ 格式。对于一个大于 $0$ 的浮点数 $d$ ，可以用 $R$ 格式的整数来表示。给定一个转换参数 $n$ ，将浮点数转换为 $R$ 格式整数的做法是：

将浮点数乘以 $2^n$ 。
四舍五入到最接近的整数。

输入格式：

一行一个整数 $n$ 和一个浮点数 $d$ 。

输出格式：

一行一个整数表示 $d$ 用 $R$ 格式表示出的值。

数据范围与说明：

样例 1 解释

$3.14 \times 2^2 = 12.56$ ，四舍五入后为 $13$ 。

数据规模与约定

用 $t$ 表示将 $d$ 视为字符串时的长度。

对于 $50\%$ 的数据，保证 $n \le 10$ ， $t \le 15$ 。
对于全部的测试数据，保证 $1 \le n \le 1000$ ， $1 \le t \le 1024$ ，保证 $d$ 是小数，即包含小数点。

输入输出样例 #1

输入：

2 3.14

输出：

题意

简述：

将浮点数乘以 $2^n$ 。
四舍五入到最接近的整数。

代码

C++

#include
using namespace std;
int n,l;
string d;
int a[1000000];
void func(){
    for(int i=1;i<=l;i++){
        a[i]*=2;
    }
    for(int i=1;i<=l;i++){
        a[i+1]+=a[i]/10;
        a[i]%=10;
    }
    if(a[l+1]){
        l++;
    }
}
int main(){
    cin>>n>>d;
    reverse(d.begin(),d.end());
    int index=d.find(".");
    d.erase(index,1);
    l=d.size();
    for(int i=0;i+1]=d[i]-'0';
    for(int i=1;i<=n;i++){
        func();
    }
    if(a[index]>=5){
a[index+1]++;
    }
    for(int i=index+1;i<=l;i++)
{
a[i+1]+=a[i]/10;
a[i]%=10;
}
if(a[l+1])  l++;
for(int i=l;i>index;i--)
cout<
    return 0;
}

【题解】P10902

2025-02-27T09:22:50.000Z

P10902（洛谷题面）

题目

题目描述：

小蓝在无聊时随机生成了一个长度为 $n$ 的整数数组，数组中的第 $i$ 个数为 $a_i$ ，他觉得随机生成的数组不太美观，想把它变成回文数组，也是就对于任意 $i\in [1,n]$ 满足 $a_i=a_{n-i+1}$ 。小蓝一次操作可以指定相邻的两个数，将它们一起加 $1$ 或减 $1$ ；也可以只指定一个数加 $1$ 或减 $1$ ，请问他最少需要操作多少次能把这个数组变成回文数组？

输入格式：

输入的第一行包含一个正整数 $n$ 。

第二行包含 $n$ 个整数 $a_1, a_2,\cdots, a_n$ ，相邻整数之间使用一个空格分隔。

输出格式：

输出一行包含一个整数表示答案。

数据范围与说明：

【样例说明】

第一次操作将 $a_1, a_2$ 加 $1$ ，变为 $2, 3, 3, 4$ ；

后面两次操作将 $a_1$ 加 $1$ ，变为 $4,3,3,4$ 。

【评测用例规模与约定】

对于 $20\%$ 的评测用例， $1 \le n \le 10$ ；
对于所有评测用例， $1 \le n \le 10^5$ ， $-10^6 \le a_i \le 10^6$ 。

输入输出样例 #1

输入：

1
2

4
1 2 3 4

输出：

题意

简述：

代码

C

#include
using namespace std;
#define endl '\n'
const int N=1e5+10;
long long a[N],b[N],ans=0;
int main(){
    ios_sync_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin>>n;
    for(int i=0;icin>>a[i];
    for(int i=0;i<(n+1)/2;i++){
        if(a[i]>a[n-i+1]){
            b[i]=a[n-i+1]-a[i];
        }else{
            b[n-i+1]=a[i]-a[n-i+1];
        }
    }
    for(int i=0;i
        long long m=min(b[i],b[i+1]);
        b[i]-=m;
        b[i+1]-=m;
        ans+=m;
        ans+=b[i];
    }
    cout<endl;
    return 0;
}

C++

#include
using namespace std;
#define endl '\n'
const int N=1e5+10;
long long a[N],b[N],ans=0;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)    cin>>a[i];
    for(int i=1;i<=(n+1)/2;i++){
        if(a[i]+1]){
            b[i]=a[n-i+1]-a[i];
        }else{
            b[n-i+1]=a[i]-a[n-i+1];
        }
    }
    for(int i=1;i<=n;i++){
        long long m=min(b[i],b[i+1]);
        b[i]-=m;
        b[i+1]-=m;
        ans+=m;
        ans+=b[i];
    }
    cout<
    return 0;
}

【题解】P11041

2025-02-26T10:11:09.000Z

P11041（洛谷题面）

题目

题目描述：

小蓝和朋友们在玩一个报数游戏。由于今年是 $2024$ 年，他们决定要从小到大轮流报出是 $20$ 或 $24$ 倍数的正整数。前 $10$ 个被报出的数是： $20,24,40,48,60,72,80,96,100,120$ 。请问第 $202420242024$ 个被报出的数是多少？

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只输出这个整数，填写多余的内容将无法得分。

输入格式：

本题无输入。

输出格式：

一行一个整数，表示你算出的答案。

数据范围与说明：

代码

#include
using namespace std;
typedef long long ll;
int main(){
    printf("2429042904288");
    return 0;
}

蓝桥杯 2023 省赛 - 岛屿个数

2025-02-25T01:00:00.000Z

蓝桥杯 2023 岛屿个数

题目描述

给定组测试数据，每组数据是一张的二值地图，字符 1 表示陆地，字符 0 表示海洋，地图之外视为海水。两个相邻的 1（上、下、左、右四个方向）属于同一个岛屿。若某个岛屿完全被另一个岛屿包围，则称其为子岛屿；统计时只需统计最外层岛屿的数量，子岛屿不计入答案。

输入格式

第一行一个整数。
接下来每组数据：

第一行两个整数；
接下来行，每行一个长度为的字符串。

输出格式

对每组数据输出一个整数，表示非子岛屿的数量。

思路

先从地图边界出发，使用 BFS/DFS 遍历海洋，标记所有与外海相连的海水；
在外海遍历过程中，如果遇到未访问的陆地，就说明发现了一个新的最外层岛屿，对其进行 BFS/DFS 并标记整座岛；
如果地图中没有与外海相连的海水，说明整张图都是陆地——此时答案为 1。

代码

#include 
using namespace std;

const int N = 55;
int grid[N][N];
bool visSea[N][N], visLand[N][N];
int dx4[4] = {-1, 0, 1, 0};
int dy4[4] = {0, -1, 0, 1};
int dx8[8] = {-1,-1,-1,0,0,1,1,1};
int dy8[8] = {-1,0,1,-1,1,-1,0,1};
int n, m;

inline bool inside(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m;
}

void bfsLand(int sx, int sy) {
    queueint,int>> q;
    q.push({sx, sy});
    visLand[sx][sy] = true;
    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();
        for (int d = 0; d < 4; ++d) {
            int nx = x + dx4[d], ny = y + dy4[d];
            if (inside(nx, ny) && grid[nx][ny] && !visLand[nx][ny]) {
                visLand[nx][ny] = true;
                q.push({nx, ny});
            }
        }
    }
}

int bfsSea(int sx, int sy) {
    queueint,int>> q;
    q.push({sx, sy});
    visSea[sx][sy] = true;
    int islands = 0;
    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();
        for (int d = 0; d < 8; ++d) {
            int nx = x + dx8[d], ny = y + dy8[d];
            if (!inside(nx, ny)) continue;
            if (!grid[nx][ny] && !visSea[nx][ny]) {
                visSea[nx][ny] = true;
                q.push({nx, ny});
            } else if (grid[nx][ny] && !visLand[nx][ny]) {
                ++islands;
                bfsLand(nx, ny);
            }
        }
    }
    return islands;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T; cin >> T;
    while (T--) {
        cin >> n >> m;
        for (int i = 0; i < n; ++i) {
            string s; cin >> s;
            for (int j = 0; j < m; ++j) grid[i][j] = s[j] - '0';
        }
        memset(visSea, 0, sizeof(visSea));
        memset(visLand, 0, sizeof(visLand));

        int ans = 0;
        bool touched = false;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (i == 0 || i == n - 1 || j == 0 || j == m - 1) {
                    if (!grid[i][j] && !visSea[i][j]) {
                        touched = true;
                        ans += bfsSea(i, j);
                    }
                }
            }
        }
        if (!touched) ans = 1;
        cout << ans << '\n';
    }
    return 0;
}

【题解】P1706

2025-02-24T15:20:27.000Z

P1706

题目

题目描述：

按照字典序输出自然数 $1$ 到 $n$ 所有不重复的排列，即 $n$ 的全排列，要求所产生的任一数字序列中不允许出现重复的数字。

输入格式：

一个整数 $n$ 。

输出格式：

由 $1 \sim n$ 组成的所有不重复的数字序列，每行一个序列。

每个数字保留 $5$ 个场宽。

数据范围与说明：

$1 \leq n \leq 9$ 。

输入输出样例 #1

输入：

输出：

1    2    3
1    3    2
2    1    3
2    3    1
3    1    2
3    2    1

代码

#include
using namespace std;
bool a[100];
int n;
void dfs(int pos,vector<int>&arr){
    if(pos==n){
        for(int &x:arr) cout<<setw(5)<
        cout<
        return ;
    }
    for(int i=1;i<=n;i++){
        if(!a[i]){
            a[i]=true;
            arr.push_back(i);
            dfs(pos+1,arr);
            arr.pop_back();
            a[i]=false;
        }
    }
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    vector<int>arr;
    cin>>n;
    dfs(0,arr);
    return 0;
}

【题解】P1157

2025-02-24T14:14:43.000Z

P1157

题目

题目描述：

排列与组合是常用的数学方法，其中组合就是从 $n$ 个元素中抽出 $r$ 个元素（不分顺序且 $r \le n$ ），我们可以简单地将 $n$ 个元素理解为自然数 $1,2,\dots,n$ ，从中任取 $r$ 个数。

现要求你输出所有组合。

例如 $n=5,r=3$ ，所有组合为：

$123,124,125,134,135,145,234,235,245,345$ 。

输入格式：

一行两个自然数 $n,r(1$ 。

输出格式：

所有的组合，每一个组合占一行且其中的元素按由小到大的顺序排列，每个元素占三个字符的位置，所有的组合也按字典顺序。

注意哦！输出时，每个数字需要 $3$ 个场宽。以 C++ 为例，你可以使用下列代码：

1	cout << setw(3) << x;

输出占 $3$ 个场宽的数 $x$ 。注意你需要头文件 iomanip。

数据范围与说明：

输入输出样例 #1

输入：

5 3

输出：

代码

#include
using namespace std;
int n,r;
void dfs(int pos,int start,vector<int> &tmp){
    if(pos==r){
        for(int &x:tmp){
            cout<<setw(3)<
        }
        cout<
        return;
    }
    for(int i=start;i<=n;i++){
        tmp.push_back(i);
        dfs(pos+1,i+1,tmp);
        tmp.pop_back();
    }
}
int main(){
    vector<int>a;
    cin>>n>>r;
    dfs(0,1,a);
    return 0;
}

【题解】P1036 [NOIP 2002 普及组] 选数

2025-02-23T14:14:48.000Z

P1036 [NOIP 2002 普及组] 选数（洛谷题面）

题目

题目描述：

已知 $n$ 个整数 $x_1,x_2,\cdots,x_n$ ，以及 $1$ 个整数 $k$ （ $k$ ）。从 $n$ 个整数中任选 $k$ 个整数相加，可分别得到一系列的和。例如当 $n=4$ ， $k=3$ ， $4$ 个整数分别为 $3,7,12,19$ 时，可得全部的组合与它们的和为：

$3+7+12=22$

$3+7+19=29$

$7+12+19=38$

$3+12+19=34$

现在，要求你计算出和为素数共有多少种。

例如上例，只有一种的和为素数： $3+7+19=29$ 。

输入格式：

第一行两个空格隔开的整数 $n,k$ （ $1 \le n \le 20$ ， $k$ ）。

第二行 $n$ 个整数，分别为 $x_1,x_2,\cdots,x_n$ （ $1 \le x_i \le 5\times 10^6$ ）。

输出格式：

输出一个整数，表示种类数。

数据范围与说明：

【题目来源】

NOIP 2002 普及组第二题

输入输出样例 #1

输入：

1 2	4 3 3 7 12 19

输出：

题意

简述：

$3+7+12=22$

$3+7+19=29$

$7+12+19=38$

$3+12+19=34$

现在，要求你计算出和为素数共有多少种。

例如上例，只有一种的和为素数： $3+7+19=29$ 。

代码

C++

#include
using namespace std;
typedef long long ll;
ll n,a[25],k,ans=0,sum[25];
bool check(ll x){
    if(x==1)    return false;
    for(ll i=2;i
        if(x%i==0)  return false;
    }
    return true;
}

void solve(ll total,ll pos,ll start){
    if(pos==k){
        if(check(total)){
            ans++;
        }
        return ;
    }
    
    for(int i=start;i
        solve(total+a[i],pos+1,i+1);
    }
    return ;
}

int main(){
    cin>>n>>k;
    for(int i=0;i
        cin>>a[i];
    }
    solve(0,0,0);
    cout<
    return 0;
}

【题解】P1618 三连击（升级版）

2025-02-23T12:39:30.000Z

P1618 三连击（升级版）（洛谷题面）

题目

题目描述：

将 $1, 2,\ldots, 9$ 共 $9$ 个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 $A:B:C$ ，试求出所有满足条件的三个三位数，若无解，输出 No!!!。

//感谢黄小U饮品完善题意

输入格式：

三个数， $A,B,C$ 。

输出格式：

若干行，每行 $3$ 个数字。按照每行第一个数字升序排列。

数据范围与说明：

保证 $0 \le A$ 。

$\text{upd 2022.8.3}$ ：新增加二组 Hack 数据。

输入输出样例 #1

输入：

1 2 3

输出：

192 384 576
219 438 657
273 546 819
327 654 981

代码

#include
using namespace std;
int a,b,c,x[10];
bool used[10]={0},ans=false;
int func(int s){
    int sum=0;
    for(int i=3*s-2;i<=3*s;i++){
        sum*=10;
        sum+=x[i];
    }
    return sum;
}
void solve(int n){
    if(n==10&&(func(1)*b==func(2)*a)&&(func(3)*a==func(1)*c)){
        cout<<func(1)<<" "<<func(2)<<" "<<func(3)<
        ans=true;
        return ;
    }
    for(int i=1;i<=9;i++){
        if(!used[i]){
            x[n]=i;
            used[i]=true;
            solve(n+1);
            used[i]=false;
        }
    }
    return ;
}
int main(){
    cin>>a>>b>>c;
    solve(1);
    if(!ans)    cout<<"No!!!";
    return 0;
}

烤鸡 - 题解

2025-02-23T08:02:10.000Z

烤鸡（洛谷题面）

题目

题目描述：

猪猪 Hanke 特别喜欢吃烤鸡（本是同畜牲，相煎何太急！）Hanke 吃鸡很特别，为什么特别呢？因为他有 $10$ 种配料（芥末、孜然等），每种配料可以放 $1$ 到 $3$ 克，任意烤鸡的美味程度为所有配料质量之和。

现在， Hanke 想要知道，如果给你一个美味程度 $n$ ，请输出这 $10$ 种配料的所有搭配方案。

输入格式：

一个正整数 $n$ ，表示美味程度。

输出格式：

第一行，方案总数。

第二行至结束， $10$ 个数，表示每种配料所放的质量，按字典序排列。

如果没有符合要求的方法，就只要在第一行输出一个 $0$ 。

数据范围与说明：

对于 $100\%$ 的数据， $n \leq 10000$ 。

输入输出样例 #1

输入：

输出：

10
1 1 1 1 1 1 1 1 1 2 
1 1 1 1 1 1 1 1 2 1 
1 1 1 1 1 1 1 2 1 1 
1 1 1 1 1 1 2 1 1 1 
1 1 1 1 1 2 1 1 1 1 
1 1 1 1 2 1 1 1 1 1 
1 1 1 2 1 1 1 1 1 1 
1 1 2 1 1 1 1 1 1 1 
1 2 1 1 1 1 1 1 1 1 
2 1 1 1 1 1 1 1 1 1

代码

#include
using namespace std;
int n,kind,m1[10000][10],m2[10];
void func(int total,int a){
    if(a==10){
        if(total==n){
            for (int j = 0; j < 10; j++) {
                m1[kind][j] = m2[j];
            }   
            kind++;
        }
        return ;
    }
    if(total>=n)    return;
    for(int i=1;i<=3;i++){
        m2[a]=i;
        func(total+i,a+1);
    }     
}
int main(){
    cin>>n;
    if (n < 10 || n > 30) {
        cout <<"0"<< endl;
        return 0;
    }
    func(0,0);
    cout<
    for(int i=0;i
        for(int j=0;j<10;j++){
            cout<" ";
        }
        cout<
    }
    return 0;
}

【题解】P2241

2025-02-21T10:34:40.000Z

P2241

题目

题目描述：

有一个 $n \times m$ 方格的棋盘，求其方格包含多少正方形、长方形（不包含正方形）。

输入格式：

一行，两个正整数 $n,m$ （ $n \leq 5000,m \leq 5000$ ）。

输出格式：

一行，两个正整数，分别表示方格包含多少正方形、长方形（不包含正方形）。

数据范围与说明：

输入输出样例 #1

输入：

2 3

输出：

8 10

代码

#include
using namespace std;
long long n,m,sqr,rec;
int main(){
    cin>>n>>m;
    for(int i=0;i
        for(int j=0;j
            if(i==j)    sqr+=(n-i)*(m-j);
            else    rec+=(n-i)*(m-j);
        }
    }
    cout<" "<
    return 0;
}

【题解】P1601 高精度加法

2025-02-18T11:28:12.000Z

P1601 高精度加法（洛谷题面）

题目

题目描述：

给定两个非负整数 $a,b$ ，求它们的和。不用考虑负数。

输入格式：

输入共两行，每行一个非负整数，分别为 $a,b$ 。

输出格式：

输出一行一个非负整数，表示 $a+b$ 的值。

数据范围与说明：

对于 $20\%$ 的测试数据， $a,b \le 10^9$ ；
对于 $40\%$ 的测试数据， $a,b \le 10^{18}$ ；
对于 $100\%$ 的测试数据， $0\le a,b \le 10^{500}$ 。

输入输出样例 #1

输入：

1
2

1
1

输出：

输入输出样例 #2

输入：

1
2

1001
9099

输出：

代码

#include
using namespace std;
string a,b,result="";
string add(string a,string b){
    if(a.size()size()){
        swap(a,b);
    }
    int len_a=a.size();
    int len_b=b.size();
    int diff=len_a-len_b;
    int carry=0;
    for(int i=a.size()-1;i>=0;i--){
        int digit1=a[i]-'0';    
        int digit2=(i>=diff)?(b[i-diff]-'0'):0;
        int sum=digit1+digit2+carry;
        carry=sum/10;
        result.push_back(sum%10+'0');
    }
    if(carry){
        result.push_back(carry+'0');
    }
    reverse(result.begin(),result.end());
    return result;
}
int main(){
    cin>>a;
    cin>>b;
    string num=add(a,b);
    cout<
    return 0;
}

【题解】P1307

2025-02-10T14:27:28.000Z

P1307

题目

题目描述：

给定一个整数 $N$ ，请将该数各个位上数字反转得到一个新数。新数也应满足整数的常见形式，即除非给定的原数为零，否则反转后得到的新数的最高位数字不应为零（参见样例 2）。

输入格式：

一个整数 $N$ 。

输出格式：

一个整数，表示反转后的新数。

数据范围与说明：

【数据范围】

。

noip2011 普及组第一题

输入输出样例 #1

输入：

输出：

输入输出样例 #2

输入：

-380

输出：

-83

代码

#include
using namespace std;
int main(){
    string s;
    cin>>s;
    if(s[0]=='0')   cout<<0;
    while(s.back()=='0'&&!s.empty()){
        s.erase(s.size()-1);
    }
    reverse(s.begin(),s.end());
    if(s.back()=='-'){
        s.erase(s.size()-1);
        cout<<"-"<
    }else{
        cout<
    }
    return 0;
}

【深基2.习6】Apples Prologue / 苹果和虫子 - 题解

2025-02-10T13:22:40.000Z

【深基2.习6】Apples Prologue / 苹果和虫子（洛谷题面）

题目

题目描述：

小 B 喜欢吃苹果。她现在有 $m$ （ $1 \le m \le 100$ ）个苹果，吃完一个苹果需要花费 $t$ （ $0 \le t \le 100$ ）分钟，吃完一个后立刻开始吃下一个。现在时间过去了 $s$ （ $1 \le s \le 10000$ ）分钟，请问她还有几个完整的苹果？

输入格式：

输入三个非负整数表示 $m, t, s$ 。

输出格式：

输出一个整数表示答案。

数据范围与说明：

如果你出现了 RE，不如检查一下被零除？

输入输出样例 #1

输入：

50 10 200

输出：

代码

#include
using namespace std;
int main(){
    int m,t,s;
    cin>>m>>t>>s;
    if(t==0)
    {
        cout<<0;
        return 0;
    }
    if(s%t==0){
        cout<<max(m-s/t,0);
    }else{
        cout<<max(m-s/t-1,0);
    }
    return 0;
}

【题解】P1567

2025-02-09T19:06:26.000Z

P1567

题目

题目描述：

炎热的夏日，KC 非常的不爽。他宁可忍受北极的寒冷，也不愿忍受厦门的夏天。最近，他开始研究天气的变化。他希望用研究的结果预测未来的天气。

经历千辛万苦，他收集了连续 $N(1 \leq N \leq 10^6)$ 天的最高气温数据。

现在，他想知道最高气温一直上升的最长连续天数。

输入格式：

第 1 行：一个整数 $N$ 。 $1 \leq N \leq 10^6$

第 2 行： $N$ 个空格隔开的整数，表示连续 $N$ 天的最高气温。 $0 \leq$ 最高气温 $\leq 10^9$ 。

输出格式：

1 行：一个整数，表示最高气温一直上升的最长连续天数。

数据范围与说明：

输入输出样例 #1

输入：

1 2	10 1 2 3 2 4 5 6 8 5 9

输出：

代码

#include
using namespace std;
int a[1000005];
int main(){
    int n,ans=1;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    int count=1;
    for(int i=2;i<=n;i++){
        if(a[i]>a[i-1]){
            count++;
            ans=max(ans,count);
        }else{
            count=1;
        }
    }
    cout<
    return 0;
}

【题解】P1506

2025-02-08T19:34:15.000Z

P1506

题目

题目描述：

oibh 被突来的洪水淹没了，还好 oibh 总部有在某些重要的地方起一些围墙。用 * 号表示，而一个四面被围墙围住的区域洪水是进不去的。

oibh 总部内部也有许多重要区域，每个重要区域在图中用一个 0 表示。

现在给出 oibh 的围墙建设图，问有多少个没被洪水淹到的重要区域。

输入格式：

第一行为两个正整数 $x,y$ 。

接下来 $x$ 行，每行 $y$ 个字符，由 * 和 0 组成，表示 oibh 总部的建设图。

输出格式：

输出没被水淹没的 oibh 总部的 0 的数量。

数据范围与说明：

对于 $100\%$ 的数据， $1 \le x,y \le 500$ 。

输入输出样例 #1

输入：

输出：

输入输出样例 #2

输入：

5 5
*****
*0*0*
**0**
*0*0*
*****

输出：

代码

#include 
using namespace std;
int n,m;
int a[501][501];
int kx[5]={0,1,-1,0,0}; 
int ky[5]={0,0,0,1,-1};
void dfs(int x,int y){
    a[x][y]=1;
    for(int i=1;i<=4;i++){
        int x0=x+kx[i];
        int y0=y+ky[i];
        if(x0>0&&x0<=n&&y0>0&&y0<=m&&a[x0][y0]==0)  dfs(x0,y0);
    }
}
int main(){
    char e;
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>e;
            if(e=='*')  a[i][j]=1;
            else    a[i][j]=0;
        }
    }
    for(int i=1;i<=n;i++){
        if(a[i][1]==0) dfs(i,1);
        if(a[i][m]==0) dfs(i,m); 
    }
    for(int i=1;i<=m;i++){
        if(a[1][i]==0) dfs(1,i);
        if(a[n][i]==0) dfs(n,i); 
    }
    int s=0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(a[i][j]==0)s++;
        }
    }
    cout<
    return 0;
}

【题解】P10442

2025-02-04T10:22:33.000Z

P10442（洛谷题面）

题目

题目描述：

给定字符串 $s,t$ 。

现在你要在 $s,t$ 中删除一些字符并将它们重新排列使 $s=t$ 。

问操作后的 $|s|$ （即字符串 $s$ 的长度）最大是多少？

输入格式：

第一行一个字符串 $s$ 。

第二行一个字符串 $t$ 。

输出格式：

一行一个整数，表示操作后的 $|s|$ 的最大值。

数据范围与说明：

在第一个样例中，将 a 删除，留下 bc。

此时 $|s|=2$ ，可以证明这是最优解。

在第二个样例中，将 aaaaa 删除，留下空串。
将 bbbbb 删除，留下空串。

此时 $|s|=0$ ，可以证明这是最优解。

本题采用捆绑测试。

记 $n=\max(|s|,|t|)$ 。

$\text{Subtask}$		特殊性质	总分值
$1$	$10$	无	$25$
$2$	$10^5$	$\text{A}$	$25$
$3$	$10^5$	$\text{B}$	$25$
$4$	$10^5$	无	$25$

对于 $100\%$ 的数据， $1 \le |s|,|t| \le 10^5$ ，字符串均由小写字母组成。

特殊性质 $\text{A}$ ： $s$ 是一个 $\text{a}\sim\text{z}$ 的排列。

特殊性质 $\text{B}$ ：保证 $s_i,t_i\in\{\text{a},\text{b} \}$ 。

输入输出样例 #1

输入：

1
2

abc
bc

输出：

输入输出样例 #2

输入：

1 2	aaaaa bbbbb

输出：

题意

简述：

给定字符串 $s,t$ 。

现在你要在 $s,t$ 中删除一些字符并将它们重新排列使 $s=t$ 。

问操作后的 $|s|$ （即字符串 $s$ 的长度）最大是多少？

代码

C++

#include 
using namespace std;

int main() {
    string s, t;
    cin >> s >> t;
    vector<int> count_s(26, 0), count_t(26, 0);

    for (char c : s) {
        count_s[c - 'a']++;
    }

    for (char c : t) {
        count_t[c - 'a']++;
    }

    int ans = 0;
    for (int i = 0; i < 26; i++) {
        ans += min(count_s[i], count_t[i]);
    }
    cout << ans << endl;

    return 0;
}

【题解】P1051

2025-01-24T12:23:23.000Z

P1051（洛谷题面）

题目

题目描述：

某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种，获取的条件各自不同：

院士奖学金，每人 $8000$ 元，期末平均成绩高于 $80$ 分（ $>80$ ），并且在本学期内发表 $1$ 篇或 $1$ 篇以上论文的学生均可获得；
五四奖学金，每人 $4000$ 元，期末平均成绩高于 $85$ 分（ $>85$ ），并且班级评议成绩高于 $80$ 分（ $>80$ ）的学生均可获得；
成绩优秀奖，每人 $2000$ 元，期末平均成绩高于 $90$ 分（ $>90$ ）的学生均可获得；
西部奖学金，每人 $1000$ 元，期末平均成绩高于 $85$ 分（ $>85$ ）的西部省份学生均可获得；
班级贡献奖，每人 $850$ 元，班级评议成绩高于 $80$ 分（ $>80$ ）的学生干部均可获得；

只要符合条件就可以得奖，每项奖学金的获奖人数没有限制，每名学生也可以同时获得多项奖学金。例如姚林的期末平均成绩是 $87$ 分，班级评议成绩 $82$ 分，同时他还是一位学生干部，那么他可以同时获得五四奖学金和班级贡献奖，奖金总数是 $4850$ 元。

现在给出若干学生的相关数据，请计算哪些同学获得的奖金总数最高（假设总有同学能满足获得奖学金的条件）。

输入格式：

第一行是 $1$ 个整数 $N$ ，表示学生的总数。

接下来的 $N$ 行每行是一位学生的数据，从左向右依次是姓名，期末平均成绩，班级评议成绩，是否是学生干部，是否是西部省份学生，以及发表的论文数。姓名是由大小写英文字母组成的长度不超过 $20$ 的字符串（不含空格）；期末平均成绩和班级评议成绩都是 $0$ 到 $100$ 之间的整数（包括 $0$ 和 $100$ ）；是否是学生干部和是否是西部省份学生分别用 $1$ 个字符表示， $\tt Y$ 表示是， $\tt N$ 表示不是；发表的论文数是 $0$ 到 $10$ 的整数（包括 $0$ 和 $10$ ）。每两个相邻数据项之间用一个空格分隔。

输出格式：

共 $3$ 行。

第 $1$ 行是获得最多奖金的学生的姓名。如果有两位或两位以上的学生获得的奖金最多，输出他们之中在输入文件中出现最早的学生的姓名。
第 $2$ 行是这名学生获得的奖金总数。
第 $3$ 行是这 $N$ 个学生获得的奖学金的总数。

数据范围与说明：

【数据范围】

对于 $100\%$ 的数据，满足 $1 \le N \le 100$ 。

【题目来源】

NOIP 2005 提高组第一题

输入输出样例 #1

输入：

4
YaoLin 87 82 Y N 0
ChenRuiyi 88 78 N Y 1
LiXin 92 88 N N 0
ZhangQin 83 87 Y N 1

输出：

1
2
3

ChenRuiyi
9000
28700

题意

简述：

某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种，获取的条件各自不同：

院士奖学金，每人 $8000$ 元，期末平均成绩高于 $80$ 分（ $>80$ ），并且在本学期内发表 $1$ 篇或 $1$ 篇以上论文的学生均可获得；
五四奖学金，每人 $4000$ 元，期末平均成绩高于 $85$ 分（ $>85$ ），并且班级评议成绩高于 $80$ 分（ $>80$ ）的学生均可获得；
成绩优秀奖，每人 $2000$ 元，期末平均成绩高于 $90$ 分（ $>90$ ）的学生均可获得；
西部奖学金，每人 $1000$ 元，期末平均成绩高于 $85$ 分（ $>85$ ）的西部省份学生均可获得；
班级贡献奖，每人 $850$ 元，班级评议成绩高于 $80$ 分（ $>80$ ）的学生干部均可获得；

现在给出若干学生的相关数据，请计算哪些同学获得的奖金总数最高（假设总有同学能满足获得奖学金的条件）。

代码

C++

#include
using namespace std;
int main(){
    int n,score1,score2,sum=0,max=0,total=0,paper;
    char a,b;
    string name,maxn;
    cin>>n;
    while(n--){
        cin>>name>>score1>>score2>>a>>b>>paper;
        if(score1>80 && paper>0) 
            sum+=8000;
        if(score1>85 && score2>80) 
            sum+=4000;
        if(score1>90) 
            sum+=2000;
        if(score1>85 && b=='Y')
            sum+=1000;
        if(score2>80 && a=='Y')
            sum+=850;
        total+=sum;
        if(sum>max)
            maxn=name,max=sum;
        sum=0;
    }
    cout<
    return 0;
}

【题解】P1035 [NOIP 2002 普及组] 级数求和

2025-01-24T12:09:15.000Z

P1035 [NOIP 2002 普及组] 级数求和（洛谷题面）

题目

题目描述：

已知： $S_n= 1+\dfrac{1}{2}+\dfrac{1}{3}+…+\dfrac{1}{n}$ 。显然对于任意一个整数 $k$ ，当 $n$ 足够大的时候， $S_n>k$ 。

现给出一个整数 $k$ ，要求计算出一个最小的 $n$ ，使得 $S_n>k$ 。

输入格式：

一个正整数 $k$ 。

输出格式：

一个正整数 $n$ 。

数据范围与说明：

【数据范围】

对于 $100\%$ 的数据， $1\le k \le 15$ 。

【题目来源】

NOIP 2002 普及组第一题

输入输出样例 #1

输入：

输出：

题意

简述：

已知： $S_n= 1+\dfrac{1}{2}+\dfrac{1}{3}+…+\dfrac{1}{n}$ 。显然对于任意一个整数 $k$ ，当 $n$ 足够大的时候， $S_n>k$ 。

现给出一个整数 $k$ ，要求计算出一个最小的 $n$ ，使得 $S_n>k$ 。

代码

C++

#include
using namespace std;
int main(){
    int k;
    double sum=0;
    cin>>k;
    int n=1;
    while(true){
        sum+=(double)1/n;
        if(sum>k){
            break;
        }
        n++;
    }
    cout<
    return 0;
}

Synchronized 与 ReentrantLock 的区别

2025-01-23T13:28:00.000Z

Synchronized 与 ReentrantLock 的区别

synchronized：隐式锁，JVM 自动加锁 / 释放锁

ReentrantLock：显式锁，需要手动 lock() / unlock()

ReentrantLock 本质上是基于 AQS 实现的。

synchronized是非公平锁然后ReentrantLock 有公平锁有非公平锁

ReentrantLock 支持中断lock.lockInterruptibly();还有超时获取锁

1
2
3

if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try { } finally { lock.unlock(); }
}

	synchronized	ReentrantLock
锁类型	隐式锁	显式锁
释放方式	自动	手动
公平锁	不支持	支持
可中断	不支持	支持
超时获取	不支持	支持
底层	JVM	AQS

ReentrantLock的使用场景

一般场景我优先使用 synchronized，代码简单且 JVM 已做了大量优化；当需要超时获取锁、可中断、公平性或多个条件队列时，我会使用 ReentrantLock，它提供了更灵活、更可控的并发能力。

【题解】P1029

2025-01-23T10:39:13.000Z

P1029（洛谷题面）

题目

题目描述：

输入两个正整数 $x_0, y_0$ ，求出满足下列条件的 $P, Q$ 的个数：

$P,Q$ 是正整数。
要求 $P, Q$ 以 $x_0$ 为最大公约数，以 $y_0$ 为最小公倍数。

试求：满足条件的所有可能的 $P, Q$ 的个数。

输入格式：

一行两个正整数 $x_0, y_0$ 。

输出格式：

一行一个数，表示求出满足条件的 $P, Q$ 的个数。

数据范围与说明：

$P,Q$ 有 $4$ 种：

$3, 60$ 。
$15, 12$ 。
$12, 15$ 。
$60, 3$ 。

对于 $100\%$ 的数据， $2 \le x_0, y_0 \le {10}^5$ 。

【题目来源】

NOIP 2001 普及组第二题

输入输出样例 #1

输入：

3 60

输出：

题意

简述：

输入两个正整数 $x_0, y_0$ ，求出满足下列条件的 $P, Q$ 的个数：

$P,Q$ 是正整数。
要求 $P, Q$ 以 $x_0$ 为最大公约数，以 $y_0$ 为最小公倍数。

试求：满足条件的所有可能的 $P, Q$ 的个数。

代码

C++

#include
using namespace std;
typedef long long ll;
ll gcd(int x,int y){
    while(x%y){
        int tmp=x%y;
        x=y;
        y=tmp;
    }
    return y;
}
ll lcm(int x,int y){
    return x*y/gcd(x,y);
}

int main(){
    ll x,y;
    cin>>x>>y;
    ll count=0;
     for (int i = x; i <= y; i ++) { 
        int j = x * y / i;      
        if (gcd(i, j) == x && lcm(i, j) == y) {
            count++;
        }
    }
    cout<
    return 0;
}

洛谷 P10389 蓝桥杯 2024 省赛成绩统计

2025-01-20T02:00:00.000Z

蓝桥杯 2024 省赛 A：成绩统计

题目描述

有 $n$ 位同学，按照进教室的顺序依次得到编号 $1 \ldots n$ ，第 $i$ 位同学的成绩为 $a_i$ 。小蓝依次查看同学成绩：当他看完前 $x$ 位同学的成绩时，可以在这 $x$ 个人中任意挑出 $k$ 名同学，计算他们成绩的方差。请问至少需要查看多少位同学，才有可能找到一组方差严格小于阈值 $T$ 的 $k$ 人集合。如果始终无法满足条件，输出 $-1$ 。

方差 $\sigma^2$ 的定义为

$\sigma^2 = \frac{1}{k}\sum_{i=1}^{k}(v_i-\bar v)^2,\quad\bar v = \frac{1}{k}\sum_{i=1}^{k}v_i.$

输入格式

第一行：三个整数 $n,k,T$ 。
第二行： $n$ 个整数 $a_1,a_2,\ldots,a_n$ 。

输出格式

输出一个整数表示最少需要查看的同学数量；若无法找到满足条件的集合，输出 -1。

样例

前三人只能选到 $\{3,2,5\}$ ，方差为约 $1.56$ ；观察到第四人后可以选 $\{3,2,2\}$ ，方差约 $0.22 < 1$ ，因此答案为 4。

思路

对答案二分枚举 $x$ ，表示“只看前 $x$ 位同学”是否可行。
对前 $x$ 个成绩复制并排序，方差最小的 $k$ 人一定是排序后相邻的 $k$ 个。
使用前缀和维护滑动窗口内的和与平方和，快速计算每组 $k$ 个数的方差。
如果存在某组方差不超过阈值，则当前 $x$ 可行，继续收缩右端；否则扩大搜索范围。

代码

#include 
using namespace std;

const int MAXN = 100005;
long long n, k, T;
long long a[MAXN], tmp[MAXN], prefix[MAXN], prefixSq[MAXN];

bool check(long long x) {
    for (int i = 1; i <= x; ++i) tmp[i] = a[i];
    sort(tmp + 1, tmp + x + 1);
    prefix[0] = prefixSq[0] = 0;
    for (int i = 1; i <= x; ++i) {
        prefix[i] = prefix[i - 1] + tmp[i];
        prefixSq[i] = prefixSq[i - 1] + tmp[i] * tmp[i];
    }
    auto variance = [&](int l, int r) {
        long long sum = prefix[r] - prefix[l - 1];
        long long sumSq = prefixSq[r] - prefixSq[l - 1];
        long double avg = (long double)sum / k;
        long double var = (sumSq - 2 * avg * sum + k * avg * avg) / k;
        return var;
    };
    for (int i = k; i <= x; ++i) {
        if (variance(i - k + 1, i) <= T) return true;
    }
    return false;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> k >> T;
    for (int i = 1; i <= n; ++i) cin >> a[i];

    long long l = k, r = n, ans = -1;
    while (l <= r) {
        long long mid = (l + r) / 2;
        if (check(mid)) {
            ans = mid;
            r = mid - 1;
        } else {
            l = mid + 1;
        }
    }
    cout << ans << '\n';
    return 0;
}

【题解】P3918

2025-01-19T19:02:28.000Z

P3918

题目

题目描述：

神犇航空开展了一项载客特技飞行业务。每次飞行长 $n$ 个单位时间，每个单位时间可以进行一项特技动作，可选的动作有 $k$ 种，每种动作有一个刺激程度 $c_i$ 。如果连续进行相同的动作，乘客会感到厌倦，所以定义某次动作的价值为(距上次该动作的时间) ，若为第一次进行该动作，价值为 $0$ 。安排一种方案，使得总价值最大。

输入格式：

第一行，两个整数， $n$ 和 $k$ ，如上所述；

第二行， $k$ 个整数，表示 $k$ 种动作的 $c_i$ 值。

输出格式：

仅一行，一个整数，表示最大总价值。

数据范围与说明：

数据规模与约定

对于 $10\%$ 的测试数据， $n \le 20$ ， $k \le 3$ 。
对于 $100\%$ 的测试数据， $1 \le n \le 10^3$ ， $1 \le k \le 300$ ， $0 \le c_i \le 10^3$ 。

输入输出样例 #1

输入：

1
2

5 2
2 2

输出：

代码

#include 
using namespace std;
int main() {
    int n, k;
    cin >> n >> k;
    vector<int> c(k);
    for (int i = 0; i < k; i++) {
        cin >> c[i];
    }
    sort(c.begin(), c.end(), greater<int>());
    int left = 0, right = n - 1;
    int ans = 0;
    for (int i = 0; i < k; i++) {
        if (left > right) break;
        ans += (right - left) * c[i];
        left++;
        right--;
    }
    cout << ans << endl;
    return 0;
}

【题解】P1028

2025-01-18T12:05:24.000Z

P1028（洛谷题面）

题目

题目描述：

给出正整数 $n$ ，要求按如下方式构造数列：

只有一个数 $n$ 的数列是一个合法的数列。
在一个合法的数列的末尾加入一个正整数，但是这个正整数不能超过该数列最后一项的一半，可以得到一个新的合法数列。

请你求出，一共有多少个合法的数列。两个合法数列 $a, b$ 不同当且仅当两数列长度不同或存在一个正整数 $i \leq |a|$ ，使得 $a_i \neq b_i$ 。

输入格式：

输入只有一行一个整数，表示 $n$ 。

输出格式：

输出一行一个整数，表示合法的数列个数。

数据范围与说明：

样例 1 解释

满足条件的数列为：

$6$
$6, 1$
$6, 2$
$6, 3$
$6, 2, 1$
$6, 3, 1$

数据规模与约定

对于全部的测试点，保证 $1 \leq n \leq 10^3$ 。

说明

本题数据来源是 NOIP 2001 普及组第一题，但是原题的题面描述和数据不符，故对题面进行了修改，使之符合数据。原题面如下，谨供参考：

我们要求找出具有下列性质数的个数（包含输入的正整数 $n$ ）。
先输入一个正整数 $n$ （ $n \le 1000$ ），然后对此正整数按照如下方法进行处理：
不作任何处理；
在它的左边拼接一个正整数，但该正整数不能超过原数，或者是上一个被拼接的数的一半；
加上数后，继续按此规则进行处理，直到不能再加正整数为止。

感谢 @dbxxx 对本题情况的反馈，原题面的问题见本贴。

输入输出样例 #1

输入：

输出：

题意

简述：

给出正整数 $n$ ，要求按如下方式构造数列：

只有一个数 $n$ 的数列是一个合法的数列。
在一个合法的数列的末尾加入一个正整数，但是这个正整数不能超过该数列最后一项的一半，可以得到一个新的合法数列。

请你求出，一共有多少个合法的数列。两个合法数列 $a, b$ 不同当且仅当两数列长度不同或存在一个正整数 $i \leq |a|$ ，使得 $a_i \neq b_i$ 。

代码

C++

#include
using namespace std;
int n,f[1005];

int main(){
    cin>>n;
    f[0]=f[1]=1;
    for(int i=2;i<=n;i++){
        if(i%2==0){
            f[i]=f[i-1]+f[i/2];
        }else{
            f[i]=f[i-1];
        }
    }
    cout<
    return 0;
}

【题解】P10389

2025-01-16T14:17:43.000Z

P10389（洛谷题面）

题目

题目描述：

小蓝的班上有 $n$ 个人，一次考试之后小蓝想统计同学们的成绩，第 $i$ 名同学的成绩为 $a_i$ 。当小蓝统计完前 $x$ 名同学的成绩后，他可以从 $1 \sim x$ 中选出任意 $k$ 名同学的成绩，计算出这 $k$ 个成绩的方差。小蓝至少要检查多少个人的成
绩，才有可能选出 $k$ 名同学，他们的方差小于一个给定的值 $T$ ？
提示： $k$ 个数 $v_1, v_2, \cdots , v_k$ 的方差 $\sigma^2$ 定义为： $\sigma^2=\dfrac {\sum_{i=1}^k(v_i-\bar v)^2} k$ ，其中 $\bar v$ 表示
$v_i$ 的平均值， $\bar v = \dfrac {\sum_{i=1}^k v_i} k$ 。

输入格式：

输入的第一行包含三个正整数，相邻整数之间使用一个空格分隔。

第二行包含 $n$ 个正整数 $a_1, a2, \cdots, a_n$ ，相邻整数之间使用一个空格分隔。

输出格式：

输出一行包含一个整数表示答案。如果不能满足条件，输出 $-1$ 。

数据范围与说明：

检查完前三名同学的成绩后，只能选出，方差为；

检查完前四名同学的成绩后，可以选出，方差为，所以答案为。

对于 $10\%$ 的评测用例，保证 $1 ≤ n, k ≤ 10^2$ ；
对于 $30\%$ 的评测用例，保证 $1 ≤ n, k ≤ 10^3$ ；
对于所有评测用例，保证，，。

输入输出样例 #1

输入：

1 2	5 3 1 3 2 5 2 3

输出：

题意

简述：

代码

C++

#include 
using namespace std;
typedef long long LL;
typedef double db;
LL n,k,T,a[100005],s[100005],qsum[100005],qpf[100005];
bool check(LL x){
    for(int i=1;i<=x;i++)   s[i]=a[i];
    sort(s+1,s+x+1);
    qsum[0]=0,qpf[0]=0;
    for(int i=1;i<=x;i++)   qsum[i]=qsum[i-1]+s[i];
    for(int i=1;i<=x;i++)   qpf[i]=qpf[i-1]+s[i]*s[i];
    db fc=0,avg=0;
    for(int i=1;i<=k;i++) avg+=(db)s[i]/k;
    fc=(qpf[k]-2*avg*qsum[k]+k*avg*avg)/k;
    if(T>=fc){
        return true;
    }
    for(int i=k+1;i<=x;i++){
        avg=avg-(db)s[i-k]/k+(db)s[i]/k;
        fc=(qpf[i]-qpf[i-k]-2*avg*(qsum[i]-qsum[i-k])+k*avg*avg)/k;
        if(T>=fc){
            return true;
        }
    }
    return false;
}

int main(){
    cin>>n>>k>>T;
    for(int i=1;i<=n;i++)   cin>>a[i];
    LL l=k,r=n;
    LL ans=n+1;
    while(l<=r){
        int mid=l+(r-l)/2;
        if(check(mid)){
            ans=mid;
            r=mid-1;
        }else{
            l=mid+1;
        }
    }
    if(ans>n) cout<<-1;
    else cout<
    return 0;
}

【题解】P1115 最大子段和

2025-01-15T09:35:01.000Z

P1115 最大子段和（洛谷题面）

题目

题目描述：

给出一个长度为 $n$ 的序列 $a$ ，选出其中连续且非空的一段使得这段和最大。

输入格式：

第一行是一个整数，表示序列的长度 $n$ 。

第二行有 $n$ 个整数，第 $i$ 个整数表示序列的第 $i$ 个数字 $a_i$ 。

输出格式：

输出一行一个整数表示答案。

数据范围与说明：

样例 1 解释

选取 $[3, 5]$ 子段 $\{3, -1, 2\}$ ，其和为 $4$ 。

数据规模与约定

对于 $40\%$ 的数据，保证 $n \leq 2 \times 10^3$ 。
对于 $100\%$ 的数据，保证 $1 \leq n \leq 2 \times 10^5$ ， $-10^4 \leq a_i \leq 10^4$ 。

2026/01/21：增加一组 hack 数据。

输入输出样例 #1

输入：

1 2	7 2 -4 3 -1 2 -4 3

输出：

代码

#include
using namespace std;
int sum[200005],a[200005];
int main(){
    int n,ans=-2147483647;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        sum[i]=sum[i-1]+a[i];
        sum[i]=max(a[i],sum[i]);
        ans=max(ans,sum[i]);
    }
    cout<
    return 0;
}

【题解】P1271

2025-01-14T14:06:32.000Z

P1271

题目

题目描述：

学校正在选举学生会成员，有 $n$ （ $1 \le n\le 999$ ）名候选人，每名候选人编号分别从 $1$ 到 $n$ ，现在收集到了 $m$ （ $1 \le m \le 2000000$ ）张选票，每张选票都写了一个候选人编号。现在想把这些堆积如山的选票按照投票数字从小到大排序。设第 $i$ （ $1 \le i \le m$ ）张选票上的数字为 $a_i$ ，则保证有 $1 \le a_i \le n$ 。

输入格式：

输入 $n$ 和 $m$ 以及 $m$ 个选票上的数字。

输出格式：

求出排序后的选票编号。

数据范围与说明：

输入输出样例 #1

输入：

1 2	5 10 2 5 2 2 5 2 2 2 1 2

输出：

1	1 2 2 2 2 2 2 2 5 5

代码

#include 
using namespace std;
int n,m;
int main(){
    cin>>n>>m;
    vector<int>a(m);
    for(int i=0;i>a[i];
    sort(a.begin(),a.end());
    for(int i=0;i" ";
    return 0;
}

【题解】P1806

2025-01-14T12:23:12.000Z

P1806

题目

题目描述：

路人甲准备跑 $n$ 圈来锻炼自己的身体，他准备分多次（ $\gt1$ ）跑完，每次都跑正整数圈，然后休息下再继续跑。

为了有效地提高自己的体能，他决定每次跑的圈数都必须比上次跑的多。

可以假设他刚开始跑了 $0$ 圈，那么请问他可以有多少种跑完这 $n$ 圈的方案？

输入格式：

一行一个整数，代表 $n$ 。

输出格式：

一个整数表示跑完这 $n$ 圈的方案数。

数据范围与说明：

数据规模与约定

对于 $100\%$ 的数据，保证 $5\le n\le 500$ 。

输入输出样例 #1

输入：

输出：

995645335

代码

#include 
using namespace std;
int n;
long long dp[505];
int main(){
    cin>>n;
    dp[0]=1;
    for(int i=1;i<=n;i++){
        for(int j=n;j>=i;j--){
            dp[j]+=dp[j-i];
        }
    }
    cout<-1;
    return 0;
}

【题解】P1419

2025-01-13T15:29:07.000Z

P1419

题目

题目描述：

给定一个长度为 $n$ 的序列 $a$ ，定义 $a_i$ 为第 $i$ 个元素的价值。现在需要找出序列中最有价值的“段落”。段落的定义是长度在 $[S, T]$ 之间的连续序列。最有价值段落是指平均值最大的段落。

段落的平均值 等于 段落总价值 除以 段落长度。

输入格式：

第一行一个整数 $n$ ，表示序列长度。

第二行两个整数 $S$ 和 $T$ ，表示段落长度的范围，在 $[S, T]$ 之间。

第三行到第 $n+2$ 行，每行一个整数表示每个元素的价值指数。

输出格式：

一个实数，保留 $3$ 位小数，表示最优段落的平均值。

数据范围与说明：

【数据范围】

对于 $30\%$ 的数据有 $n \le 1000$ 。

对于 $100\%$ 的数据有 $1 \le n \le 100000$ ， $1 \le S \le T \le n$ ， $-{10}^4 \le a_i \le {10}^4$ 。

【题目来源】

tinylic 改编

输入输出样例 #1

输入：

输出：

1.000

代码

#include
using namespace std;
int a[100005];
double b[100005],sum[100005];
int n;
int s,t;
bool check(double x){
    sum[0]=0;
    deque<int> q;
    for(int i=1;i<=n;i++){
        b[i]=(double)a[i]-x;
        sum[i]=sum[i-1]+b[i];
    }
    for(int i=1;i<=n;i++){
        if(i>=s){
            while(!q.empty()&&sum[q.back()]>sum[i-s]){
                q.pop_back();
            }
            q.push_back(i-s);   
        }
        while(!q.empty()&&q.front()
            q.pop_front();
        }
        if(!q.empty()&&sum[i]-sum[q.front()]>=0){
             return true;
        }
    }
    return false;
}
int main(){
    cin>>n;
    cin>>s>>t;    
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    double ans;
    double l=-10000,r=10000;
    while(r-l>1e-5){
       double mid=l+(r-l)/2;
        if(check(mid)){
            ans=mid;
            l=mid;
        }else{
            r=mid;
        }
    }
    printf("%.3lf",ans);
    return 0;
}

【题解】P10903

2025-01-11T12:56:29.000Z

P10903（洛谷题面）

题目

题目描述：

在库存管理系统中，跟踪和调节商品库存量是关键任务之一。小蓝经营的仓库中存有多种商品，这些商品根据类别和规格被有序地分类并编号，编号范围从 $1$ 至 $n$ 。初始时，每种商品的库存量均为 $0$ 。

为了高效地监控和调整库存量，小蓝的管理团队设计了 $m$ 个操作，每个操作涉及到一个特定的商品区间，即一段连续的商品编号范围（例如区间 $[L, R]$ ）。执行这些操作时，区间内每种商品的库存量都将增加 $1$ 。然而，在某些情况下，管理团队可能会决定不执行某些操作，使得这些操作涉及的商品区间内的库存量不会发生改变，维持原有的状态。

现在，管理团队需要一个评估机制，来确定如果某个操作未被执行，那么最终会有多少种商品的库存量为 $0$ 。对此，请你为管理团队计算出，对于每个操作，如果不执行该操作而执行其它操作，库存量为 $0$ 的商品的种类数。

输入格式：

输入的第一行包含两个整数 $n$ 和 $m$ ，分别表示商品的种类数和操作的个数。

接下来的 $m$ 行，每行包含两个整数 $L$ 和 $R$ ，表示一个操作涉及的商品区间。

输出格式：

输出 $m$ 行，每行一个整数，第 $i$ 行的整数表示如果不执行第 $i$ 个操作，则最终库存量为 $0$ 的商品种类数。

数据范围与说明：

【样例说明】

考虑不执行每个操作时，其余操作对商品库存的综合影响：

不执行操作 $1$ ：剩余的操作是操作 $2$ （影响区间 $[2, 4]$ ）和操作 $3$ （影响区间 $[3, 5]$ ）。执行这两个操作后，商品库存序列变为 $[0, 1, 2, 2, 1]$ 。在这种情况下，只有编号为 $1$ 的商品的库存量为 $0$ 。因此，库存量为 $0$ 的商品种类数为 $1$ 。
不执行操作 $2$ ：剩余的操作是操作 $1$ （影响区间 $[1, 2]$ ）和操作 $3$ （影响区间 $[3, 5]$ ）。执行这两个操作后，商品库存序列变为 $[1, 1, 1, 1, 1]$ 。在这种情况下，所有商品的库存量都不为 $0$ 。因此，库存量为 $0$ 的商品种类数为 $0$ 。
不执行操作 $3$ ：剩余的操作是操作 $1$ （影响区间 $[1, 2]$ ）和操作 $2$ （影响区间 $[2, 4]$ ）。执行这两个操作后，商品库存序列变为 $[1, 2, 1, 1, 0]$ 。在这种情况下，只有编号为 $5$ 的商品的库存量为 $0$ 。因此，库存量为 $0$ 的商品种类数为 $1$ 。

【评测用例规模与约定】

对于 $20\%$ 的评测用例， $1 \le n,m \le 5 \times 10^3$ ， $1\le L \le R \le n$ 。
对于所有评测用例， $1 \le n,m \le 3 \times 10^5$ ， $1 \le L \le R \le n$ 。

输入输出样例 #1

输入：

输出：

1
2
3

1
0
1

题意

简述：

代码

C++

#include
using namespace std;
int l[300005],r[300005],a[300005],s[300005],sum=0;
int main(){
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=m;++i){
        cin>>l[i]>>r[i];
        a[l[i]]++;
        a[r[i]+1]--;
    }
    for(int i=1;i<=n;++i)
{
a[i]+=a[i-1];
if(a[i]==0) sum++;
s[i]=s[i-1]+(a[i]==1);
}
    for(int i=1;i<=m;++i) 
        cout<-1]+sum<
    return 0;
}

【题解】P2249 【深基13.例1】查找

2024-12-31T14:20:33.000Z

P2249 【深基13.例1】查找（洛谷题面）

题目

题目描述：

输入 $n$ 个不超过 $10^9$ 的单调不减的（就是后面的数字不小于前面的数字）非负整数 $a_1,a_2,\dots,a_{n}$ ，然后进行 $m$ 次询问。对于每次询问，给出一个整数 $q$ ，要求输出这个数字在序列中第一次出现的编号，如果没有找到的话输出 $-1$ 。

输入格式：

第一行 $2$ 个整数 $n$ 和 $m$ ，表示数字个数和询问次数。

第二行 $n$ 个整数，表示这些待查询的数字。

第三行 $m$ 个整数，表示询问这些数字的编号，从 $1$ 开始编号。

输出格式：

输出一行， $m$ 个整数，以空格隔开，表示答案。

数据范围与说明：

数据保证， $1 \leq n \leq 10^6$ ， $0 \leq a_i,q \leq 10^9$ ， $1 \leq m \leq 10^5$

本题输入输出量较大，请使用较快的 IO 方式。

输入输出样例 #1

输入：

1
2
3

11 3
1 3 3 3 5 7 9 11 13 15 15
1 3 6

输出：

1 2 -1

代码

#include 
using namespace std;
int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    vector<int> arr(n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }
    while (m--) {
        int x;
        scanf("%d", &x);
        auto it = lower_bound(arr.begin(), arr.end(), x);
        int idx = it - arr.begin();
        if (it == arr.end() || *it != x) {
            printf("-1 ");
        } else {
            printf("%d ", idx+1);
        }
    }
    return 0;
}

【题解】P1873

2024-12-30T12:14:57.000Z

P1873

题目

题目描述：

伐木工人 Mirko 需要砍 $M$ 米长的木材。对 Mirko 来说这是很简单的工作，因为他有一个漂亮的新伐木机，可以如野火一般砍伐森林。不过，Mirko 只被允许砍伐一排树。

Mirko 的伐木机工作流程如下：Mirko 设置一个高度参数 $H$ （米），伐木机升起一个巨大的锯片到高度 $H$ ，并锯掉所有树比 $H$ 高的部分（当然，树木不高于 $H$ 米的部分保持不变）。Mirko 就得到树木被锯下的部分。例如，如果一排树的高度分别为 $20,15,10$ 和 $17$ ，Mirko 把锯片升到 $15$ 米的高度，切割后树木剩下的高度将是 $15,15,10$ 和 $15$ ，而 Mirko 将从第 $1$ 棵树得到 $5$ 米，从第 $4$ 棵树得到 $2$ 米，共得到 $7$ 米木材。

Mirko 非常关注生态保护，所以他不会砍掉过多的木材。这也是他尽可能高地设定伐木机锯片的原因。请帮助 Mirko 找到伐木机锯片的最大的整数高度 $H$ ，使得他能得到的木材至少为 $M$ 米。换句话说，如果再升高 $1$ 米，他将得不到 $M$ 米木材。

输入格式：

第 $1$ 行 $2$ 个整数 $N$ 和 $M$ ， $N$ 表示树木的数量， $M$ 表示需要的木材总长度。

第 $2$ 行 $N$ 个整数表示每棵树的高度。

输出格式：

$1$ 个整数，表示锯片的最高高度。

数据范围与说明：

对于 $100\%$ 的测试数据， $1\le N\le10^6$ ， $1\le M\le2\times10^9$ ，树的高度 $\le 4\times 10^5$ ，所有树的高度总和 $>M$ 。

输入输出样例 #1

输入：

1 2	4 7 20 15 10 17

输出：

输入输出样例 #2

输入：

1 2	5 20 4 42 40 26 46

输出：

代码

#include
using namespace std;
typedef long long ll;
int n,m;
int ans;
ll check(vector<int> arr,int mid){
    ll sum=0;
    for(int x:arr){
        if(x>mid){
            sum+=x-mid;
        }
    }
    return sum;
}
int main(){
    cin>>n>>m;
    vector<int>arr(n);
    for(ll i=0;i
        cin>>arr[i];
    }
    sort(arr.begin(),arr.end());
    int left=0,right=arr[n-1];
    while(left<=right){
        int mid=left+(right-left)/2;
        ll sum=check(arr,mid);
        if(sum>=m){
            ans=mid;
            left=mid+1;
        }
        else{
            right=mid-1;
        }
    }
    cout<
    return 0;
}

【题解】P10424

2024-12-29T14:20:53.000Z

P10424（洛谷题面）

题目

题目描述：

一个整数如果按从低位到高位的顺序，奇数位（个位、百位、万位……）上的数字是奇数，偶数位（十位、千位、十万位……）上的数字是偶数，我们就称之为“好数”。

给定一个正整数 $N$ ，请计算从 $1$ 到 $N$ 一共有多少个好数。

输入格式：

一个整数 $N$ 。

输出格式：

一个整数代表答案。

数据范围与说明：

样例 1 解释

$24$ 以内的好数有 $1,3,5,7,9,21,23$ ，一共 $7$ 个。

数据规模与约定

对于 $10\%$ 的测试数据， $1 \leq N \le 100$ 。
对于全部的测试数据， $1 \le N \leq 10^7$ 。

输入输出样例 #1

输入：

输出：

输入输出样例 #2

输入：

输出：

题意

简述：

给定一个正整数 $N$ ，请计算从 $1$ 到 $N$ 一共有多少个好数。

代码

C++

#include
using namespace std;
bool check(int x){
    int j=1;
    while(x){
        int i=x%10;
        if(j%2==1){
            if(i%2==0)  return false;
        }else{
            if(i%2==1)  return false;
        }
        
        x/=10;
        j++;
    }
    return true;
}

int main(){
    int n,count=0;
    cin>>n;
    for(int i=1;i<=n;i++){
        if(check(i)){
            count++;
        }
    }
    cout<
    return 0;
}

【题解】P1017 [NOIP 2000 提高组] 进制转换

2024-12-28T15:14:42.000Z

P1017 [NOIP 2000 提高组] 进制转换（洛谷题面）

题目

题目描述：

我们可以用这样的方式来表示一个十进制数：将每个阿拉伯数字乘以一个以该数字所处位置为指数，以 $10$ 为底数的幂之和的形式。例如 $123$ 可表示为 $1 \times 10^2+2\times 10^1+3\times 10^0$ 这样的形式。

与之相似的，对二进制数来说，也可表示成每个二进制数码乘以一个以该数字所处位置为指数，以 $2$ 为底数的幂之和的形式。

一般说来，任何一个正整数 $R$ 或一个负整数 $-R$ 都可以被选来作为一个数制系统的基数。如果是以 $R$ 或 $-R$ 为基数，则需要用到的数码为 $0,1,\dots,R-1$ 。

例如当 $R=7$ 时,所需用到的数码是 $0,1,2,3,4,5,6$ ，这与其是 $R$ 或 $-R$ 无关。如果作为基数的数绝对值超过 $10$ ，则为了表示这些数码，通常使用英文字母来表示那些大于 $9$ 的数码。例如对 $16$ 进制数来说,用 $A$ 表示 $10$ ，用 $B$ 表示 $11$ ，用 $C$ 表示 $12$ ，以此类推。

在负进制数中是用作为基数，例如 $-15$ （十进制）相当于 $(110001)_{-2}$ （ $-2$ 进制），并且它可以被表示为 $2$ 的幂级数的和数：

$(110001)_{-2}=1\times (-2)^5+1\times (-2)^4+0\times (-2)^3+0\times (-2)^2+0\times (-2)^1 +1\times (-2)^0$

设计一个程序，读入一个十进制数和一个负进制数的基数，并将此十进制数转换为此负进制下的数。

输入格式：

输入的每行有两个输入数据。

第一个是十进制数 $n$ 。第二个是负进制数的基数 $R$ 。

输出格式：

输出此负进制数及其基数，若此基数的绝对值超过 $10$ ，则参照 $16$ 进制的方式处理。

数据范围与说明：

数据范围

对于 $100\%$ 的数据， $-20 \le R \le -2$ ， $|n| \le 37336$ 。

输入输出样例 #1

输入：

30000 -2

输出：

1	30000=11011010101110000(base-2)

输入输出样例 #2

输入：

-20000 -2

输出：

1	-20000=1111011000100000(base-2)

输入输出样例 #3

输入：

28800 -16

输出：

1	28800=19180(base-16)

输入输出样例 #4

输入：

1	-25000 -16

输出：

1	-25000=7FB8(base-16)

题意

简述：

与之相似的，对二进制数来说，也可表示成每个二进制数码乘以一个以该数字所处位置为指数，以 $2$ 为底数的幂之和的形式。

在负进制数中是用作为基数，例如 $-15$ （十进制）相当于 $(110001)_{-2}$ （ $-2$ 进制），并且它可以被表示为 $2$ 的幂级数的和数：

$(110001)_{-2}=1\times (-2)^5+1\times (-2)^4+0\times (-2)^3+0\times (-2)^2+0\times (-2)^1 +1\times (-2)^0$

设计一个程序，读入一个十进制数和一个负进制数的基数，并将此十进制数转换为此负进制下的数。

代码

C++

#include
using namespace std;
int n,r;
int i=0;
char arr[100];
int main(){
    cin>>n>>r;
    
    int rr=r;
    printf("%d=",n);
    while(n!=0){
        int a=n%r;
        n/=r;
        if(a<0){
            a-=r;
            n++;
        }
        if(a<10){
            arr[i++]=(char)(a+48);
        }else{
            arr[i++]=(char)((a-10)+'A');
        }
    }
    
    for(int z=i-1;z>=0;z--){
        cout<
    }printf("(base%d)",rr);
    return 0;
}

【NOIP 2015 提高组】跳石头 - 题解

2024-12-27T14:28:17.000Z

【NOIP 2015 提高组】跳石头（洛谷题面）

题目

题目描述：

一年一度的“跳石头”比赛又要开始了！

这项比赛将在一条笔直的河道中进行，河道中分布着一些巨大岩石。组委会已经选择好了两块岩石作为比赛起点和终点。在起点和终点之间，有 $N$ 块岩石（不含起点和终点的岩石）。在比赛过程中，选手们将从起点出发，每一步跳向相邻的岩石，直至到达终点。

为了提高比赛难度，组委会计划移走一些岩石，使得选手们在比赛过程中的最短跳跃距离尽可能长。由于预算限制，组委会至多从起点和终点之间移走 $M$ 块岩石（不能移走起点和终点的岩石）。

输入格式：

第一行包含三个整数 $L,N,M$ ，分别表示起点到终点的距离，起点和终点之间的岩石数，以及组委会至多移走的岩石数。保证 $L \geq 1$ 且 $N \geq M \geq 0$ 。

接下来 $N$ 行，每行一个整数，第 $i$ 行的整数 $D_i\,( 0 < D_i < L)$ ，表示第 $i$ 块岩石与起点的距离。这些岩石按与起点距离从小到大的顺序给出，且不会有两个岩石出现在同一个位置。

输出格式：

一个整数，即最短跳跃距离的最大值。

数据范围与说明：

输入输出样例 1 说明

将与起点距离为 $2$ 和 $14$ 的两个岩石移走后，最短的跳跃距离为 $4$ （从与起点距离 $17$ 的岩石跳到距离 $21$ 的岩石，或者从距离 $21$ 的岩石跳到终点）。

数据规模与约定

对于 $20\%$ 的数据， $0 \le M \le N \le 10$ 。
对于 $50\%$ 的数据， $0 \le M \le N \le 100$ 。
对于 $100\%$ 的数据， $0 \le M \le N \le 50000,1 \le L \le 10^9$ 。

输入输出样例 #1

输入：

输出：

代码

#include 
using namespace std;
int l,n,m,a[50006],ans;
bool check(int mid){
    int cnt=0,j=0;
    for(int i=1;i<=n+1;i++){
        if(a[i]-a[j]
            cnt++;
        }else{
            j=i;
        }
    }
    if(cnt>m){
        return false;
    }else{
        return true;
    }
}
int main(){
    scanf("%d %d %d",&l,&n,&m);
    for(int i=1;i<=n;i++)   scanf("%d",&a[i]);
    a[n+1]=l;
    int left=0,right=l;
    while(left<=right)
     {
         int mid=left+(right-left)/2;
         if(check(mid)){
              left=mid+1;
              ans=mid;
          }
        else right=mid-1;
     }
    cout<
    return 0;
}

【题解】P1824 [USACO05FEB] 进击的奶牛 Aggressive Cows

2024-12-25T14:40:54.000Z

P1824 [USACO05FEB] 进击的奶牛 Aggressive Cows（洛谷题面）

题目

题目描述：

农夫约翰建造了一座有 $n$ 间牛舍的小屋，牛舍排在一条直线上，第 $i$ 间牛舍在 $x_i$ 的位置，但是约翰的 $m$ 头牛对小屋很不满意，因此经常互相攻击。约翰为了防止牛之间互相伤害，因此决定把每头牛都放在离其它牛尽可能远的牛舍。也就是要最大化最近的两头牛之间的距离。

牛们并不喜欢这种布局，而且几头牛放在一个隔间里，它们就要发生争斗。为了不让牛互相伤害。约翰决定自己给牛分配隔间，使任意两头牛之间的最小距离尽可能的大，那么，这个最大的最小距离是多少呢？

输入格式：

第一行用空格分隔的两个整数 $n$ 和 $m$ ；

下面 $n$ 行为 $n$ 个用空格隔开的整数，表示位置 $x_i$ 。

输出格式：

一行一个整数，表示最大的最小距离值。

数据范围与说明：

【样例解析】把牛放在 $1$ ， $4$ ， $8$ 这三个位置，距离是 $3$ 。容易证明最小距离已经最大。

【数据范围】对于 $100\%$ 的数据， $2 \le n \le 10^5$ ， $0 \le x_i \le 10^9$ ， $2 \le m \le n$ 。不保证 $x$ 数组单调递增。

输入输出样例 #1

输入：

输出：

代码

#include
using namespace std;
int n,c,a[100005];
int ans;
bool check(int mid){
    int cnt=1,p=0;
    for(int i=1;i
        if(a[i]-a[p]>=mid){
            cnt++;
            p=i;
        }
    }
    if(cnt>=c)  return true;
    else    return false;
}
int main(){
    scanf("%d %d",&n,&c);
    for(int i=0;iscanf("%d",&a[i]);
    sort(a,a+n);
    int left=0,right=a[n-1]-a[0];
    while(left<=right){
        int mid=left+(right-left)/2;
        if(check(mid)){
            ans=mid;
            left=mid+1;
        }else{
            right=mid-1;
        }
    }
    cout<
    return 0;
}

【题解】P1102 A-B 数对

2024-12-25T00:46:21.000Z

P1102 A-B 数对（洛谷题面）

题目

题目描述：

给出一串正整数数列以及一个正整数 $C$ ，要求计算出所有满足 $A - B = C$ 的数对的个数（不同位置的数字一样的数对算不同的数对）。

输入格式：

输入共两行。

第一行，两个正整数 $N,C$ 。

第二行， $N$ 个正整数，作为要求处理的那串数。

输出格式：

一行，表示该串正整数中包含的满足 $A - B = C$ 的数对的个数。

数据范围与说明：

对于 $75\%$ 的数据， $1 \leq N \leq 2000$ 。

对于 $100\%$ 的数据， $1 \leq N \leq 2 \times 10^5$ ， $0 \leq a_i <2^{30}$ ， $1 \leq C < 2^{30}$ 。

2017/4/29 新添数据两组

输入输出样例 #1

输入：

1 2	4 1 1 1 2 3

输出：

代码

#include 
using namespace std;
typedef long long ll;
const int N=2e5+5;
int a[N];
map m;
int main(){
    ll n,c;
    cin>>n>>c;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        m[a[i]]++;
        a[i]-=c;
    }
    ll ans=0;
    for(int i=1;i<=n;i++)   ans+=m[a[i]];
    cout<
    return 0;
}

【题解】P11395

2024-12-24T14:02:43.000Z

P11395

题目

题目描述：

喵喵喵群里面，吃喵喵是坏文明。

现在群友有 $q$ 个问题，每个问题形如 A or B?，其中 $A,B$ 为仅含小写字母的非空字符串。

对于每个问题，你可以回答 $A$ 或 $B$ 中的任意一个不是 eat 的字符串。特别地，如果 $A$ 和 $B$ 都是 eat，你需要回答 or。

输入格式：

输入的第一行有一个正整数 $q$ ，表示问题的数量。

之后有 $q$ 行，每行有一个问题。

输出格式：

对于每个问题，输出一行一个字符串，表示你对于这个问题的答案。

数据范围与说明：

【样例 1 解释】

对于第一个问题，你可以从 yummy 和 yucky 两个单词中的任意一个，所以既可以回答 yummy 也可以回答 yucky。注意：在这个问题输出 or 将导致答案错误。
对于第二个问题，因为第一个单词是 eat，要避开，因此必须输出 stick。
对于第三个问题，因为第二个单词是 eat，要避开，因此必须输出 rua。
对于第四个问题，两个单词都是 eat，所以要输出 or。

【样例 2 解释】

本样例共有 $32$ 种本质不同的输出（除了第 $5,6$ 个问题的两个字符串一样外，其他问题都有两种可能答案），这里仅展示其中一种可能的输出。

【数据范围】

对于全部数据，保证 $1\le q\le 100$ ，每个问题中的字符串 $A,B$ 均不超过 $100$ 个字符，且仅含有小写字符。

本题共有 $6$ 个测试点，不同测试点的分值和特殊性质见下表：

测试点编号	特殊性质	分值
1	$A,B$ 都不是 `eat`	$19$
2	$A$ 一定是 `eat`， $B$ 一定不是 `eat`	$22$
3	$B$ 一定是 `eat`	$11$
4	$A$ 一定是 `eat`	$12$
5	$A,B$ 一定有一个不是 `eat`	$13$
6	无特殊性质	$23$

输入输出样例 #1

输入：

4
yummy or yucky?
eat or stick?
rua or eat?
eat or eat?

输出：

yummy
stick
rua
or

输入输出样例 #2

输入：

7
saint or sinner?
tobe or nottobe?
ad or able?
eating or eaten?
or or or?
and or and?
oneplusoneistwo or oneplusoneisthree?

输出：

sinner
tobe
able
eaten
or
and
oneplusoneistwo

代码

#include
using namespace std;
string a,Or,b;
int main(){
    int q;
    for(cin>>q;q;q--){
        cin>>a>>Or>>b;
        b.pop_back();
        if(a=="eat"){
            if(b=="eat"){
                cout<
            }else{
                cout<
            }
        }else{
            cout<
        }
    }
    return 0;
}

【模板】堆 - 题解

2024-12-23T14:53:26.000Z

【模板】堆（洛谷题面）

题目

题目描述：

给定一个数列，初始为空，请支持下面三种操作：

给定一个整数 $x$ ，请将 $x$ 加入到数列中。
输出数列中最小的数。
删除数列中最小的数（如果有多个数最小，只删除 $1$ 个）。

输入格式：

第一行是一个整数，表示操作的次数 $n$ 。
接下来 $n$ 行，每行表示一次操作。每行首先有一个整数 $op$ 表示操作类型。

若 $op = 1$ ，则后面有一个整数 $x$ ，表示要将 $x$ 加入数列。
若 $op = 2$ ，则表示要求输出数列中的最小数。
若 $op = 3$ ，则表示删除数列中的最小数。如果有多个数最小，只删除 $1$ 个。

输出格式：

对于每个操作 $2$ ，输出一行一个整数表示答案。

数据范围与说明：

【数据规模与约定】

对于 $30\%$ 的数据，保证 $n \leq 15$ 。
对于 $70\%$ 的数据，保证 $n \leq 10^4$ 。
对于 $100\%$ 的数据，保证 $1 \leq n \leq 10^6$ ， $1 \leq x \lt 2^{31}$ ， $op \in \{1, 2, 3\}$ 。

输入输出样例 #1

输入：

输出：

1
2

2
5

代码

#include
using namespace std;
priority_queue<int,vector<int>,greater<int>>q;
int main(){
    int n;
    scanf("%d",&n);
    while(n--){
        int op;
        scanf("%d",&op);
        if(op==1){
            int x;
            scanf("%d",&x);
            q.push(x);
        }else if(op==2){
            printf("%d\n",q.top());
        }else{
            q.pop();
        }
    }
    return 0;
}

【题解】P1229

2024-12-22T12:14:25.000Z

P1229

题目

题目描述：

我们都很熟悉二叉树的前序、中序、后序遍历，在数据结构中常提出这样的问题：已知一棵二叉树的前序和中序遍历，求它的后序遍历，相应的，已知一棵二叉树的后序遍历和中序遍历序列你也能求出它的前序遍历。然而给定一棵二叉树的前序和后序遍历，你却不能确定其中序遍历序列，考虑如下图中的几棵二叉树：

所有这些二叉树都有着相同的前序遍历和后序遍历，但中序遍历却不相同。

输入格式：

共两行，第一行表示该二叉树的前序遍历结果 $s_1$ ，第二行表示该二叉树的后序遍历结果 $s_2$ 。

保证至少存在一棵二叉树满足给出的信息， $s _ 1, s _ 2$ 中只含小写字母，且在某个字符串中不存在相同的字母。

输出格式：

输出可能的中序遍历序列的总数，结果不超过 $2^{63}-1$ 。

数据范围与说明：

输入输出样例 #1

输入：

1
2

abc                           
cba

输出：

代码

#include
using namespace std;
int main(){
    string a,b;
    int ans=0;
    cin>>a;
    cin>>b;
    for(int i=0;ilength();i++){
        for(int j=1;jlength();j++){
            if(a[i]==b[j]&&a[i+1]==b[j-1]){
                ans++;
            }
        }
    }
    cout<<(1<
    return 0;
}

【题解】P1030

2024-12-21T15:05:19.000Z

P1030（洛谷题面）

题目

题目描述：

给出一棵二叉树的中序与后序排列。求出它的先序排列。（约定树结点用不同的大写字母表示，且二叉树的节点个数）。

输入格式：

共两行，均为大写字母组成的字符串，表示一棵二叉树的中序与后序排列。

输出格式：

共一行一个字符串，表示一棵二叉树的先序。

数据范围与说明：

【题目来源】

NOIP 2001 普及组第三题

输入输出样例 #1

输入：

1
2

BADC
BDCA

输出：

ABCD

题意

简述：

给出一棵二叉树的中序与后序排列。求出它的先序排列。（约定树结点用不同的大写字母表示，且二叉树的节点个数）。

代码

C++

#include
using namespace std;
string a,b;
void func(string x,string y){
    if(x.size()>0){   
        char ch=y[y.size()-1];
        cout<
        int k=x.find(ch);
        func(x.substr(0,k),y.substr(0,k));
        func(x.substr(k+1),y.substr(k,x.size()-k-1));
    }

}
int main(){
    cin>>a;
    cin>>b;
    func(a,b);
    return 0;
}

【题解】P1087

2024-12-20T13:04:12.000Z

P1087（洛谷题面）

题目

题目描述：

我们可以把由 0 和 1 组成的字符串分为三类：全 0 串称为 B 串，全 1 串称为 I 串，既含 0 又含 1 的串则称为 F 串。

FBI 树是一种二叉树，它的结点类型也包括 F 结点，B 结点和 I 结点三种。由一个长度为 $2^N$ 的 01 串 $S$ 可以构造出一棵 FBI 树 $T$ ，递归的构造方法如下：

$T$ 的根结点为 $R$ ，其类型与串 $S$ 的类型相同；
若串 $S$ 的长度大于 $1$ ，将串 $S$ 从中间分开，分为等长的左右子串 $S_1$ 和 $S_2$ ；由左子串 $S_1$ 构造 $R$ 的左子树 $T_1$ ，由右子串 $S_2$ 构造 $R$ 的右子树 $T_2$ 。

现在给定一个长度为 $2^N$ 的 01 串，请用上述构造方法构造出一棵 FBI 树，并输出它的后序遍历序列。

输入格式：

第一行是一个整数 $N(0 \le N \le 10)$ ，

第二行是一个长度为 $2^N$ 的 01 串。

输出格式：

一个字符串，即 FBI 树的后序遍历序列。

数据范围与说明：

对于 $40\%$ 的数据， $N \le 2$ ；

对于全部的数据， $N \le 10$ 。

noip2004普及组第3题

输入输出样例 #1

输入：

1 2	3 10001011

输出：

1	IBFBBBFIBFIIIFF

题意

简述：

我们可以把由 0 和 1 组成的字符串分为三类：全 0 串称为 B 串，全 1 串称为 I 串，既含 0 又含 1 的串则称为 F 串。

$T$ 的根结点为 $R$ ，其类型与串 $S$ 的类型相同；
若串 $S$ 的长度大于 $1$ ，将串 $S$ 从中间分开，分为等长的左右子串 $S_1$ 和 $S_2$ ；由左子串 $S_1$ 构造 $R$ 的左子树 $T_1$ ，由右子串 $S_2$ 构造 $R$ 的右子树 $T_2$ 。

现在给定一个长度为 $2^N$ 的 01 串，请用上述构造方法构造出一棵 FBI 树，并输出它的后序遍历序列。

代码

C++

#include
using namespace std;
char func(string x){
    if(x.length()>1){
        int mid=x.length()/2;
        cout<<func(x.substr(0,mid));
        cout<<func(x.substr(mid));
    }
    if(x==string(x.length(),'0'))   return 'B';
    if(x==string(x.length(),'1'))   return 'I';
    return 'F';
}

int main(){
    int n;
    cin>>n;
    n=1>>n;
    string s;
    cin>>s;
    cout<<func(s);

    return 0;
}

【NOIP 2013 普及组】表达式求值 - 题解

2024-12-18T02:43:57.000Z

【NOIP 2013 普及组】表达式求值（洛谷题面）

题目

题目描述：

给定一个只包含加法和乘法的算术表达式，请你编程计算表达式的值。

输入格式：

一行，为需要你计算的表达式，表达式中只包含数字、加法运算符 + 和乘法运算符 *，且没有括号，所有参与运算的数字均为 $0$ 到 $2^{31}-1$ 之间的整数。

输入数据保证这一行只有 0123456789+* 这 $12$ 种字符。

输出格式：

一个整数，表示这个表达式的值。

注意：当答案长度多于 $4$ 位时，请只输出最后位，前导不输出。

数据范围与说明：

对于 $30\%$ 的数据， $0≤$ 表达式中加法运算符和乘法运算符的总数 $≤100$ 。

对于 $80\%$ 的数据， $0≤$ 表达式中加法运算符和乘法运算符的总数 $≤1000$ 。

对于 $100\%$ 的数据， $0≤$ 表达式中加法运算符和乘法运算符的总数 $≤100000$ 。

输入输出样例 #1

输入：

1+1*3+4

输出：

输入输出样例 #2

输入：

1	1+1234567890*1

输出：

输入输出样例 #3

输入：

1	1+1000000003*1

输出：

代码

#include
using namespace std;
stack<int> s;
int main()
{
    char c;
    int a,b;
    int n=10000;
    a%=n;
    cin>>a;
    s.push(a);
    while(cin>>c>>b){
        if(c=='*'){
            a=s.top();
            s.pop();
            s.push(a*b%n);
        }else{
            s.push(b);
        }
    }
    int sum=0;
    while(!s.empty()){
        sum+=s.top();
        sum%=n;
        s.pop();
    }
    cout<
    return 0;
}

【题解】P1739 表达式括号匹配

2024-12-17T14:26:50.000Z

P1739 表达式括号匹配（洛谷题面）

题目

题目描述：

假设一个表达式有英文字母（小写）、运算符（+、-、*、/）和左右小（圆）括号构成，以 @ 作为表达式的结束符。请编写一个程序检查表达式中的左右圆括号是否匹配，若匹配，则输出 YES；否则输出 NO。表达式长度小于 $255$ ，左圆括号少于 $20$ 个。

输入格式：

一行：表达式。

输出格式：

一行：YES 或 NO。

数据范围与说明：

表达式长度小于 $255$ ，左圆括号少于 $20$ 个。

输入输出样例 #1

输入：

1	2*(x+y)/(1-x)@

输出：

YES

输入输出样例 #2

输入：

1	(25+x)(a(a+b+b)@

输出：

NO

代码

#include
using namespace std;
string s;
stack <int> stk;
int main(){
    int i=0;
    getline(cin,s);
    while(s[i]!='@')
    {
        if(stk.empty()){    
            if(s[i]==')'){
                cout<<"NO";
                return 0;
            }
        }
        if(s[i]=='('){
            stk.push(s[i]);
        }
        if(s[i]==')'){
            stk.pop();
        }
        i++;
    }
    if(stk.empty()){
        cout<<"YES";
    }else {
        cout<<"NO";
    }
    return 0;
}

【题解】P1449 后缀表达式

2024-12-17T08:48:42.000Z

P1449 后缀表达式（洛谷题面）

题目

题目描述：

所谓后缀表达式是指这样的一个表达式：式中不再引用括号，运算符号放在两个运算对象之后，所有计算按运算符号出现的顺序，严格地由左而右新进行（不用考虑运算符的优先级）。

本题中运算符仅包含 $\texttt{+-*/}$ 。保证对于 $\texttt{/}$ 运算除数不为 0。特别地，其中 $\texttt{/}$ 运算的结果需要向 0 取整（即与 C++ / 运算的规则一致）。

如： $\texttt{3*(5-2)+7}$ 对应的后缀表达式为： $\texttt{3.5.2.-*7.+@}$ 。在该式中，@ 为表达式的结束符号。. 为操作数的结束符号。

输入格式：

输入一行一个字符串 $s$ ，表示后缀表达式。

输出格式：

输出一个整数，表示表达式的值。

数据范围与说明：

数据保证， $1 \leq |s| \leq 50$ ，答案和计算过程中的每一个值的绝对值不超过 $10^9$ 。

输入输出样例 #1

输入：

1	3.5.2.-*7.+@

输出：

输入输出样例 #2

输入：

1	10.28.30./*7.-@

输出：

-7

代码

#include
using namespace std;
stack<int> num;
char s[10001];
char ccty[21];
int flag = 0, i = 0;
int numa, numb, Num;
int k = 0;
int makernum(){
int ret=0;
for(int i=0;i<=strlen(ccty)-1;++i){
if(ccty[i]=='*')break;
ret=ret*10+ccty[i]-'0';
ccty[i]='*';
}
return ret;
}
int main() {
    cin >> s;
    char cha = s[0];
    while (cha != '@') {
        if (flag == 0) i = 0;
        if (cha >= '0' && cha <= '9') {
            flag = 1;
            ccty[i] = cha;
            i++;
        }
        if (cha == '.') {
            flag = 0;
            Num = makernum();
            num.push(Num);
        }
        if ((cha < '0' || cha > '9') && cha != '.') {
            numa = num.top(); num.pop();
            numb = num.top(); num.pop();
            if (cha == '+') num.push(numb + numa);
            if (cha == '-') num.push(numb - numa);
            if (cha == '*') num.push(numb * numa);
            if (cha == '/') num.push(numb / numa);
        }
        k++;
        cha = s[k];
    }
    cout << num.top() << endl;
    return 0;
}

洛谷 P5788 【模板】单调栈

2024-12-12T15:03:53.000Z

【模板】单调栈（P5788）

题目

题目描述：

给出项数为 $n$ 的整数数列 $a_{1 \dots n}$ 。

定义函数 $f(i)$ 代表数列中第 $i$ 个元素之后第一个大于 $a_i$ 的元素的下标，即 $f(i)=\min_{i a_i} \{j\}$ 。若不存在，则 $f(i)=0$ 。

试求出 $f(1\dots n)$ 。

输入格式：

第一行一个正整数 $n$ 。

第二行 $n$ 个正整数 $a_{1\dots n}$ 。

输出格式：

一行 $n$ 个整数表示 $f(1), f(2), \dots, f(n)$ 的值。

数据范围与说明：

【数据规模与约定】

对于 $30\%$ 的数据， $n\leq 100$ ；

对于 $60\%$ 的数据， $n\leq 5 \times 10^3$ ；

对于 $100\%$ 的数据， $1 \le n\leq 3\times 10^6$ ， $1\leq a_i\leq 10^9$ 。

输入输出样例 #1

输入：

1 2	5 1 4 2 3 5

输出：

2 5 4 5 0

题意

给定一个长度为 $n$ 的序列 $a$ ，定义 $f(i)$ 为第 $i$ 个元素之后第一个严格大于 $a_i$ 的元素下标，不存在则为 $0$ 。输出 $f(1\ldots n)$ 。

思路

从右向左维护“严格递减”的单调栈：

栈中存储下标，且对应的值严格递减；
对于当前位置 $i$ ，不断弹出小于等于 $a_i$ 的下标，剩余的栈顶即为第一个更大的位置；
若栈为空，则 $f(i)=0$ ；
处理完后将 $i$ 入栈继续向左。

时间复杂度 $O(n)$ 。

代码

#include 
using namespace std;

const int N = 3'000'000 + 5;
int a[N], ans[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n; 
    cin >> n;
    for (int i = 1; i <= n; ++i) cin >> a[i];

    stack<int> st;
    for (int i = n; i >= 1; --i) {
        while (!st.empty() && a[st.top()] <= a[i]) st.pop();
        ans[i] = st.empty() ? 0 : st.top();
        st.push(i);
    }

    for (int i = 1; i <= n; ++i) {
        cout << ans[i] << (i == n ? '\n' : ' ');
    }
    return 0;
}

【题解】P5788

2024-12-12T15:03:53.000Z

P5788

题目

题目描述：

给出项数为 $n$ 的整数数列 $a_{1 \dots n}$ 。

定义函数 $f(i)$ 代表数列中第 $i$ 个元素之后第一个大于 $a_i$ 的元素的下标，即 $f(i)=\min_{i a_i} \{j\}$ 。若不存在，则 $f(i)=0$ 。

试求出 $f(1\dots n)$ 。

输入格式：

第一行一个正整数 $n$ 。

第二行 $n$ 个正整数 $a_{1\dots n}$ 。

输出格式：

一行 $n$ 个整数表示 $f(1), f(2), \dots, f(n)$ 的值。

数据范围与说明：

【数据规模与约定】

对于 $30\%$ 的数据， $n\leq 100$ ；

对于 $60\%$ 的数据， $n\leq 5 \times 10^3$ ；

对于 $100\%$ 的数据， $1 \le n\leq 3\times 10^6$ ， $1\leq a_i\leq 10^9$ 。

输入输出样例 #1

输入：

1 2	5 1 4 2 3 5

输出：

2 5 4 5 0

代码

#include
using namespace std;
int s[3000005],ans[3000005];
int main(){
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&s[i]);
    }
    stack<int> st;
    for(int i=n;i>=1;i--){
        while(!st.empty()&&s[st.top()]<=s[i]){      
            st.pop();
        }
        if(st.empty()){
            ans[i]=0;
        }else{
            ans[i]=st.top();
        }
        st.push(i);
    }
    for(int i=1;i<=n;i++){
        printf("%d ",ans[i]);
    }
    return 0;
}

【题解】P2947

2024-12-12T12:10:42.000Z

P2947

题目

题目描述：

约翰的 $N(1\le N\le10^5)$ 头奶牛站成一排，奶牛 $i$ 的身高是 $H_i(1\le H_i\le10^6)$ 。现在，每只奶牛都在向右看。对于奶牛 $i$ ，如果奶牛 $j$ 满足 $i$ 且 $H_i$ ，我们可以说奶牛 $i$ 可以仰望奶牛 $j$ 。求出每只奶牛离她最近的仰望对象。

输入格式：

第 $1$ 行输入 $N$ ，之后 $N$ 行第 $i+1$ 行输入一个身高 $H_i$ 。

输出格式：

共 $N$ 行，按顺序每行输出一只奶牛的最近仰望对象，如果没有仰望对象，输出 $0$ 。

数据范围与说明：

【输入说明】

$6$ 头奶牛的身高分别为 $3$ , $2$ , $6$ , $1$ , $1$ , $2$ 。

【输出说明】

奶牛 $1,2$ 仰望奶牛 $3$ ，奶牛 $4,5$ 仰望奶牛 $6$ ，奶牛 $3$ 和 $6$ 没有仰望对象。

【数据规模】

对于 $20\%$ 的数据： $1\le N\le10$ ；

对于 $50\%$ 的数据： $1\le N\le10^3$ ；

对于 $100\%$ 的数据： $1\le N\le10^5,1\le H_i\le10^6$ 。

输入输出样例 #1

输入：

输出：

代码

#include
using namespace std;
int h[100001],ans[100001];
int main(){
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&h[i]);
    }
    stack<int> st;
    for(int i=n;i>=1;i--){
        while(!st.empty()&&h[st.top()]<=h[i]){
            st.pop();
        }
        if(st.empty()){
            ans[i]=0;
        }else{
            ans[i]=st.top();
        }
        st.push(i);
    }
    for(int i=1;i<=n;i++){
        printf("%d\n",ans[i]);
    }
    return 0;
}

【题解】P1540 [NOIP 2010 提高组] 机器翻译

2024-12-09T15:43:55.000Z

P1540 [NOIP 2010 提高组] 机器翻译（洛谷题面）

题目

题目描述：

小晨的电脑上安装了一个机器翻译软件，他经常用这个软件来翻译英语文章。

这个翻译软件的原理很简单，它只是从头到尾，依次将每个英文单词用对应的中文含义来替换。对于每个英文单词，软件会先在内存中查找这个单词的中文含义，如果内存中有，软件就会用它进行翻译；如果内存中没有，软件就会在外存中的词典内查找，查出单词的中文含义然后翻译，并将这个单词和译义放入内存，以备后续的查找和翻译。

假设内存中有 $M$ 个单元，每单元能存放一个单词和译义。每当软件将一个新单词存入内存前，如果当前内存中已存入的单词数不超过 $M-1$ ，软件会将新单词存入一个未使用的内存单元；若内存中已存入 $M$ 个单词，软件会清空最早进入内存的那个单词，腾出单元来，存放新单词。

假设一篇英语文章的长度为 $N$ 个单词。给定这篇待译文章，翻译软件需要去外存查找多少次词典？假设在翻译开始前，内存中没有任何单词。

输入格式：

共 $2$ 行。每行中两个数之间用一个空格隔开。

第一行为两个正整数 $M,N$ ，代表内存容量和文章的长度。

第二行为 $N$ 个非负整数，按照文章的顺序，每个数（大小不超过 $1000$ ）代表一个英文单词。文章中两个单词是同一个单词，当且仅当它们对应的非负整数相同。

输出格式：

一个整数，为软件需要查词典的次数。

数据范围与说明：

样例解释

整个查字典过程如下：每行表示一个单词的翻译，冒号前为本次翻译后的内存状况：

1：查找单词 1 并调入内存。
1 2：查找单词 2 并调入内存。
1 2：在内存中找到单词 1。
1 2 5：查找单词 5 并调入内存。
2 5 4：查找单词 4 并调入内存替代单词 1。
2 5 4：在内存中找到单词 4。
5 4 1：查找单词 1 并调入内存替代单词 2。

共计查了 $5$ 次词典。

数据范围

对于 $10\%$ 的数据有 $M=1$ ， $N \leq 5$ ；
对于 $100\%$ 的数据有 $1 \leq M \leq 100$ ， $1 \leq N \leq 1000$ 。

输入输出样例 #1

输入：

1 2	3 7 1 2 1 5 4 4 1

输出：

代码

#include
using namespace std;
int n,m,l,r,a[1005],b[1005],x,ans;
int main(){
    cin>>m>>n;
    l=0;r=0;
    for(int i=1;i<=n;i++){
        scanf("%d",&x);
        if(a[x]==0){
            ans++;
            r++;
            b[r]=x;
            a[x]=1;
            if(r>m){
            l++;
            a[b[l]]=0;
        }
        }
    }
    cout<
    return 0;
}

【题解】P2422

2024-12-07T12:33:10.000Z

P2422

题目

题目描述：

kkk 做了一个人体感觉分析器。每一天，人都有一个感受值 $A_i$ ， $A_i$ 越大，表示人感觉越舒适。在一段时间 $\left[i, j\right]$ 内，人的舒适程度定义为 $\left[i, j\right]$ 中最不舒服的那一天的感受值 $\times$ $\left[i, j\right]$ 中每一天感受值的和。现在给出 kkk 在连续 $N$ 天中的感受值，请问，在哪一段时间，kkk 感觉最舒适？

输入格式：

第一行为 $N$ ，代表数据记录的天数。

第二行 $N$ 个整数，代表每一天的感受值。

输出格式：

一行，表示在最舒适的一段时间中的感受值。

数据范围与说明：

kkk 最开心的一段时间是第 $3$ 天到第 $5$ 天，开心值： $(6+4+5)\times4=60$ 。

对于 $30\%$ 的数据， $1\le N\le 100$ 。

对于 $70\%$ 的数据， $1\le N\le 2000$ 。

对于 $100\%$ 的数据， $1\le N\le 10^5$ ， $1\le \texttt{感受值}\le 10^6$ 。

输入输出样例 #1

输入：

1 2	6 3 1 6 4 5 2

输出：

代码

#include
using namespace std;
long long a[100006],s[100006],f[100006],q[100006],ans=0,tail;
int main(){
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
    }
    n++;
    a[n]=0;
    for(register int i=1;i<=n;i++){
        s[i]=s[i-1]+a[i];
    }
    for(register int i=1;i<=n;i++){
        while(a[q[tail]]>a[i]){
            f[q[tail]]+=(s[i-1]-s[q[tail]]);
            tail--;
        }
        f[i]=s[i]-s[q[tail]];
        q[++tail]=i;
    }
    for(register int i=1;i<=n-1;i++){
        ans=max(ans,f[i]*a[i]);
    }
    printf("%lld",ans);
    return 0;
}

【题解】P2629

2024-12-06T11:22:16.000Z

P2629

题目

题目描述：

Uim 在公司里面当秘书，现在有 $n$ 条消息要告知老板。每条消息有一个好坏度，这会影响老板的心情。告知完一条消息后，老板的心情等于老板之前的心情加上这条消息的好坏度。最开始老板的心情是 $0$ ，一旦老板心情到了 $0$ 以下就会勃然大怒，炒了 Uim 的鱿鱼。

Uim 为了不被炒，提前知道了这些消息（已经按时间的发生顺序进行了排列）的好坏度，希望知道如何才能不让老板发怒。

Uim 可以使用一种叫 “倒叙” 的手法，例如有 $n$ 条消息，Uim 可以任取一个整数 $k$ （ $1 \leq k \leq n$ ），先从 $k$ 事件通报到 $n$ 事件，再从 $1$ 事件通报到 $k-1$ 事件。特别的，当 $k=1$ 时按照原顺序通报。

他希望知道，有多少个这样的 $k$ 可以让老板不发怒。

输入格式：

第一行一个整数 $n$ （ $1 \le n \le10^6$ ），表示有 $n$ 个消息。

第二行 $n$ 个整数，按时间顺序给出第 $i$ 条消息的好坏度 $A_i$ （ $-10^3\le A_i \le 10^3$ ）。

输出格式：

一行一个整数，表示可行的方案个数。

数据范围与说明：

【样例解释】

通报事件的可行顺序（用编号表示）为 $2\rightarrow3\rightarrow4\rightarrow1$ 或 $3\rightarrow4\rightarrow1\rightarrow2$ （分别对应 $k=2$ 和 $k=3$ ）

通报事件的可行顺序（用好坏度表示）为 $5\rightarrow1\rightarrow2\rightarrow(-3)$ 或 $1\rightarrow2\rightarrow(-3)\rightarrow5$

【数据范围】

对于 $25\%$ 的数据， $n\le10^3$ ；
对于 $75\%$ 的数据， $n\le10^4$ ；
对于 $100\%$ 的数据， $1 \le n\le 10^6$ 。

输入输出样例 #1

输入：

1 2	4 -3 5 1 2

输出：

代码

#include 
using namespace std;
long long q[20000006],a[2000006],s[2000006];
int main(){
    int n,l=1,r=0,ans=0;
    scanf("%d",&n);
    for(register int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
    }
    for(register int i=1;i<=n-1;i++){
        a[i+n]=a[i];
    }
    for(register int i=1;i<=2*n-1;i++){
        s[i]=s[i-1]+a[i];
    }
    for(register int i=1;i<=2*n-1;i++){
        while(l<=r&&max(i-n+1,1)>q[l]){
            l++;
        }
        while(l<=r&&s[q[r]]>=s[i]){
            r--;
        }
        q[++r]=i;
        if(i-n+1>0&&s[q[l]]-s[i-n]>=0){
            ans++;
        }
    }
    printf("%d\n",ans);
}

【题解】P1714

2024-12-05T13:25:19.000Z

P1714

题目

题目描述：

今天是小 Z 的生日，同学们为他带来了一块蛋糕。这块蛋糕是一个长方体，被用不同色彩分成了 $n$ 个相同的小块，每小块都有对应的幸运值。

小 Z 作为寿星，自然希望吃到的蛋糕的幸运值总和最大，但小 Z 最多又只能吃 $m(m\le n)$ 小块的蛋糕。

请你帮他从这 $n$ 小块中找出连续的 $k(1 \le k\le m)$ 块蛋糕，使得其上的总幸运值最大。

形式化地，在数列 $\{p_n\}$ 中，找出一个子段 $[l,r](r-l+1\le m)$ ，最大化 $\sum\limits_{i=l}^rp_i$ 。

输入格式：

第一行两个整数 $n,m$ 。分别代表共有 $n$ 小块蛋糕，小 Z 最多只能吃 $m$ 小块。

第二行 $n$ 个整数，第 $i$ 个整数 $p_i$ 代表第 $i$ 小块蛋糕的幸运值。

输出格式：

仅一行一个整数，即小 Z 能够得到的最大幸运值。

数据范围与说明：

数据规模与约定

对于 $20\%$ 的数据，有 $1\le n\le100$ 。
对于 $100\%$ 的数据，有 $1\le n\le5\times 10^5$ ， $|p_i|≤500$ 。

保证答案的绝对值在 $[0,2^{31}-1]$ 之内。

输入输出样例 #1

输入：

1 2	5 2 1 2 3 4 5

输出：

输入输出样例 #2

输入：

1 2	6 3 1 -2 3 -4 5 -6

输出：

代码

#include 
using namespace std;
int ans=-233333333,n,m,a,sum[500006];
deque<int>q;
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        cin>>a;
        sum[i]=sum[i-1]+a;
    }
    q.push_back(0);
    for(int i=1;i<=n;i++){
        while(q.front()+m
            q.pop_front();
        }
        ans=max(ans,sum[i]-sum[q.front()]);
        while(!q.empty()&&sum[q.back()]>=sum[i])
        {
            q.pop_back();
        }
        q.push_back(i);
    }
     cout<
}

【题解】P2032

2024-12-04T00:50:42.000Z

P2032

题目

题目描述：

有一个 $1 \times n$ 的矩阵，有 $n$ 个整数。

现在给你一个可以盖住连续 $k$ 个数的木板。

一开始木板盖住了矩阵的第 $1 \sim k$ 个数，每次将木板向右移动一个单位，直到右端与第 $n$ 个数重合。

每次移动前输出被覆盖住的数字中最大的数是多少。

输入格式：

第一行两个整数 $n,k$ ，表示共有 $n$ 个数，木板可以盖住 $k$ 个数。

第二行 $n$ 个整数，表示矩阵中的元素。

输出格式：

共 $n - k + 1$ 行，每行一个整数。

第 $i$ 行表示第 $i \sim i + k - 1$ 个数中最大值是多少。

数据范围与说明：

对于 $20\%$ 的数据， $1 \leq k \leq n \leq 10^3$ 。

对于 $50\%$ 的数据， $1 \leq k \leq n \leq 10^4$ 。

对于 $100\%$ 的数据， $1 \leq k \leq n \leq 2 \times 10^6$ ，矩阵中的元素大小不超过 $10^4$ 并且均为正整数。

输入输出样例 #1

输入：

1 2	5 3 1 5 3 4 2

输出：

1
2
3

5
5
4

代码

#include 
using namespace std;
int q[2000006];
int a[2000006];
int main(){
    int n,k;
    cin>>n>>k;
    int left=1;
    int right=1;
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    q[1]=1;
    for(int i=1;i<=n;i++){
        if(q[left]<=i-k){
            left++;
        }
        while(left<=right&&a[q[right]]<=a[i]){
            right--;
        }
        q[++right]=i;
        if(i>=k){
            printf("%d\n",a[q[left]]);
        }
    }
    return 0;
}

【题解】P1440

2024-12-03T17:10:54.000Z

P1440

题目

题目描述：

一个含有 $n$ 项的数列，求出每一项前的 $m$ 个数到它这个区间内的最小值。若前面的数不足 $m$ 项则从第 $1$ 个数开始，若前面没有数则输出 $0$ 。

输入格式：

第一行两个整数，分别表示 $n$ ， $m$ 。

第二行， $n$ 个正整数，为所给定的数列 $a_i$ 。

输出格式：

$n$ 行，每行一个整数，第 $i$ 个数为序列中 $a_i$ 之前 $m$ 个数的最小值。

数据范围与说明：

对于 $100\%$ 的数据，保证 $1\le m\le n\le2\times10^6$ ， $1\le a_i\le3\times10^7$ 。

输入输出样例 #1

输入：

1 2	6 2 7 8 1 4 3 2

输出：

代码

#include
using namespace std;
int q[2000005], a[2000005];
int main(){
    int n,m;
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++)    scanf("%d",&a[i]);
    int front=1,rear=0;
    printf("0\n");
    for(int i=1;i<=n-1;i++){
        while(front<=rear&&q[front]<=i-m){
            front++;
        }
        while(front<=rear&&a[q[rear]]>=a[i]){
            rear--;
        }
        q[++rear]=i;
        printf("%d\n",a[q[front]]);
    }
}

【题解】P8637

2024-11-29T07:20:11.000Z

P8637（洛谷题面）

题目

题目描述：

有 $N$ 个瓶子，编号 $1 \sim N$ ，放在架子上。

比如有 $5$ 个瓶子：

$2,1,3,5,4$

要求每次拿起 $2$ 个瓶子，交换它们的位置。

经过若干次后，使得瓶子的序号为：

$1,2,3,4,5$

对于这么简单的情况，显然，至少需要交换 $2$ 次就可以复位。

如果瓶子更多呢？你可以通过编程来解决。

输入格式：

第一行：一个正整数 $N$ （ $N<10000$ ），表示瓶子的数目。

第二行： $N$ 个正整数，用空格分开，表示瓶子目前的排列情况。

输出格式：

输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。

数据范围与说明：

时限 1 秒, 256M。蓝桥杯 2016 年第七届省赛

蓝桥杯 2016 年省赛 B 组 I 题。

输入输出样例 #1

输入：

1 2	5 3 1 2 5 4

输出：

输入输出样例 #2

输入：

1 2	5 5 4 3 2 1

输出：

代码

#include 
using namespace std;
int main(){
    int arr[10001];
    int n,count=0;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&arr[i]);
    } 
    for(int i=1;i<=n;i++){
        if(arr[i]!=i){
            for(int j=1;j<=n;j++){
                if(arr[j]==i){
                    swap(arr[j],arr[i]);
                    count++;
                }
            }
        }
    }
    printf("%d ",count);
}

【题解】P10904

2024-11-26T17:31:13.000Z

P10904（洛谷题面）

题目

题目描述：

小蓝正在数轴上挖矿，数轴上一共有 $n$ 个矿洞，第 $i$ 个矿洞的坐标为 $a_i$ 。小蓝从 $0$ 出发，每次可以向左或向右移动 $1$ 的距离，当路过一个矿洞时，就会进行挖矿作业，获得 $1$ 单位矿石，但一个矿洞不能被多次挖掘。小蓝想知道在
移动距离不超过 $m$ 的前提下，最多能获得多少单位矿石？

输入格式：

输入的第一行包含两个正整数 $n,m$ ，用一个空格分隔。

第二行包含 $n$ 个整数 $a_1, a_2,\cdots, a_n$ ，相邻整数之间使用一个空格分隔。

输出格式：

输出一行包含一个整数表示答案。

数据范围与说明：

【样例说明】

路径： $0\to -1\to 0\to 1\to 2$ ，可以对 $\{0,-1,1,2\}$ 四个矿洞挖掘并获得最多 $4$ 块矿石。

【评测用例规模与约定】

对于 $20\%$ 的评测用例， $1 \le n \le 10^3$ ；
对于所有评测用例， $1 \le n \le 10^5$ ， $-10^6 \le a_i \le 10^6$ ， $1 \le m \le 2 \times 10^6$ 。

输入输出样例 #1

输入：

1 2	5 4 0 -3 -1 1 2

输出：

题意

简述：

代码

C

#include 

const int N = 2e6 + 10;
int n,m,l[1000],r[1000],ans,cnt;

int max(int a, int b) {
    return (a > b) ? a : b;
}
int main(){
    
    scanf("%d %d",&n,&m);
    for(int i=1,x;i<=n;i++){
        scanf("%d",&x);
        if(x<0){
            l[-x]++;
        }else if(x>0){
            r[x]++;
        }else{
            cnt++;
        }
    }
    for(int i=1;i<=m;i++){
        l[i]+=l[i-1];
        r[i]+=r[i-1];
    }
    for(int i=1,t;i<=m;i++){
        t=l[i];
        if(m-i*2>0){
            t+=r[m-i*2];
        }
        ans=max(ans,t);
        t=r[i];
        if(m-i*2>0){
            t+=l[m-i*2];
        }
        ans=max(ans,t);
    }
    printf("%d\n",ans+cnt);
    return 0;
}

C++

#include 

using namespace std;

const int N = 2e6 + 10;
int n,m,l[N],r[N],ans,cnt;

int main(){
    scanf("%d %d",&n,&m);
    for(int i=1,x;i<=n;i++){
        scanf("%d",&x);
        if(x<0){
            l[-x]++;
        }else if(x>0){
            r[x]++;
        }else{
            cnt++;
        }
    }
    for(int i=1;i<=m;i++){
        l[i]+=l[i-1];
        r[i]+=r[i-1];
    }
    for(int i=1,t;i<=m;i++){
        t=l[i];
        if(m-i*2>0){
            t+=r[m-i*2];
        }
        
        
        ans=max(ans,t);
        t=r[i];
        if(m-i*2>0){
            t+=l[m-i*2];
        }
        ans=max(ans,t);
    }
    printf("%d\n",ans+cnt);
    return 0;
}

【题解】P1305 新二叉树

2024-11-26T15:47:59.000Z

P1305 新二叉树（洛谷题面）

题目

题目描述：

输入一串二叉树，输出其前序遍历。

输入格式：

第一行为二叉树的节点数 $n$ 。( $1 \leq n \leq 26$ )

后面 $n$ 行，第一个字母为节点，后两个字母分别为其左右儿子。特别地，数据保证第一行读入的节点必为根节点。

空节点用 * 表示

输出格式：

二叉树的前序遍历。

数据范围与说明：

输入输出样例 #1

输入：

6
abc
bdi
cj*
d**
i**
j**

输出：

abdicj

代码

#include 
using namespace std;
struct programmer{
    char lc;
    char rc;
}lt[130];
char h,h1;
void d(char x){
    if(x=='*'){
        return;
    }
    cout<
    d(lt[x].lc);
    d(lt[x].rc);
}
int main(){
    int n;
    scanf("%d",&n);
    cin>>h1;
    cin>>lt[h1].lc;
    cin>>lt[h1].rc;
    for(int i=2;i<=n;i++){
        cin>>h;
        cin>>lt[h].lc;
        cin>>lt[h].rc;
    }
    d(h1);
    return 0;
}

【题解】P1886 【模板】单调队列 / 滑动窗口

2024-11-09T13:46:07.000Z

P1886 【模板】单调队列 / 滑动窗口（洛谷题面）

题目

题目描述：

有一个长为 $n$ 的序列 $a$ ，以及一个大小为 $k$ 的窗口。现在这个窗口从左边开始向右滑动，每次滑动一个单位，求出每次滑动后窗口中的最小值和最大值。

例如，对于序列 $[1,3,-1,-3,5,3,6,7]$ 以及 $k = 3$ ，有如下过程：

$\def\arraystretch{1.2}\begin{array}{|c|c|c|}\hline\textsf{窗口位置} & \textsf{最小值} & \textsf{最大值} \\ \hline\verb![1 3 -1] -3 5 3 6 7 ! & -1 & 3 \\ \hline\verb! 1 [3 -1 -3] 5 3 6 7 ! & -3 & 3 \\ \hline\verb! 1 3 [-1 -3 5] 3 6 7 ! & -3 & 5 \\ \hline\verb! 1 3 -1 [-3 5 3] 6 7 ! & -3 & 5 \\ \hline\verb! 1 3 -1 -3 [5 3 6] 7 ! & 3 & 6 \\ \hline\verb! 1 3 -1 -3 5 [3 6 7]! & 3 & 7 \\ \hline\end{array}$

输入格式：

输入一共有两行，第一行有两个正整数 $n,k$ ；
第二行有 $n$ 个整数，表示序列 $a$ 。

输出格式：

输出共两行，第一行为每次窗口滑动的最小值；
第二行为每次窗口滑动的最大值。

数据范围与说明：

【数据范围】
对于 $50\%$ 的数据， $1 \le n \le 10^5$ ；
对于 $100\%$ 的数据， $1\le k \le n \le 10^6$ ， $a_i \in [-2^{31},2^{31})$ 。

输入输出样例 #1

输入：

1 2	8 3 1 3 -1 -3 5 3 6 7

输出：

1 2	-1 -3 -3 -3 3 3 3 3 5 5 6 7

代码

#include
using namespace std;
int n,k;
deque<int>q;
int a[1000005];
int main(){
    cin>>n>>k;
    for(int i=0;i
        cin>>a[i];
    }
    for(int i=0;i
        if(!q.empty()&&q.front()<=i-k){
            q.pop_front();
        }
        while(!q.empty()&&a[q.back()]>=a[i]){
            q.pop_back();
        }
        q.push_back(i);
        if(i>=k-1){
            cout<front()]<<" ";
        }
    }
    cout<
    q.clear();
    for(int i=0;i
        if(!q.empty()&&q.front()<=i-k){
            q.pop_front();
        }
        while(!q.empty()&&a[q.back()]<=a[i]){
            q.pop_back();
        }
        q.push_back(i);
        if(i>=k-1){
            cout<front()]<<" ";
        }
    }
    return 0;
}

【题解】P1085

2024-11-07T15:42:18.000Z

P1085（洛谷题面）

题目

题目描述：

津津上初中了。妈妈认为津津应该更加用功学习，所以津津除了上学之外，还要参加妈妈为她报名的各科复习班。另外每周妈妈还会送她去学习朗诵、舞蹈和钢琴。但是津津如果一天上课超过八个小时就会不高兴，而且上得越久就会越不高兴。假设津津不会因为其它事不高兴，并且她的不高兴不会持续到第二天。请你帮忙检查一下津津下周的日程安排，看看下周她会不会不高兴；如果会的话，哪天最不高兴。

输入格式：

输入包括 $7$ 行数据，分别表示周一到周日的日程安排。每行包括两个小于 $10$ 的非负整数，用空格隔开，分别表示津津在学校上课的时间和妈妈安排她上课的时间。

输出格式：

一个数字。如果不会不高兴则输出 $0$ ，如果会则输出最不高兴的是周几（用 $1, 2, 3, 4, 5, 6, 7$ 分别表示周一，周二，周三，周四，周五，周六，周日）。如果有两天或两天以上不高兴的程度相当，则输出时间最靠前的一天。

数据范围与说明：

NOIP2004 普及组第 1 题

2021-10-27：增加一组 hack 数据
2022-06-05：又增加一组 hack 数据

输入输出样例 #1

输入：

输出：

题意

简述：

代码

C

#include 
int main()
{
    int x,y,sum,day=0,max=0;
    for(int i=1;i<=7;i++){
        scanf("%d %d",&x,&y);
        sum=x+y;
        if(sum>8&&sum>max){
            max=sum;
            day=i;
        }
    }
    printf("%d",day); 
    return 0;
}

约瑟夫问题 - 题解

2024-11-06T13:58:31.000Z

约瑟夫问题（洛谷题面）

题目

题目描述：

$n$ 个人围成一圈，从第一个人开始报数,数到 $m$ 的人出列，再由下一个人重新从 $1$ 开始报数，数到 $m$ 的人再出圈，依次类推，直到所有的人都出圈，请输出依次出圈人的编号。

注意：本题和《深入浅出-基础篇》上例题的表述稍有不同。书上表述是给出淘汰 $n-1$ 名小朋友，而该题是全部出圈。

输入格式：

输入两个整数 $n,m$ 。

输出格式：

输出一行 $n$ 个整数，按顺序输出每个出圈人的编号。

数据范围与说明：

$1 \le m, n \le 100$

输入输出样例 #1

输入：

10 3

输出：

1	3 6 9 2 7 1 8 5 10 4

代码

#include 
using namespace std;
int main(){
    int n,m;
    scanf("%d %d",&n,&m);
    queue<int> q;
    for(int i=1;i<=n;i++){
        q.push(i);
    }
    int cnt=1;
    while(!q.empty()){
        if(cnt==m){
            cout<front()<<" ";
            q.pop();
            cnt=1;
        }else{
            cnt++;
            q.push(q.front());
            q.pop();
        }
    }
    return 0;
}