给你一个字符串 s ，它仅包含字符 'a' 和 'b' 。
你可以删除 s 中任意数目的字符，使得 s 平衡 。当不存在下标对 (i,j) 满足 i < j ，且 s[i] = 'b' 的同时 s[j]= 'a' ，此时认为 s 是 平衡 的。
请你返回使 s 平衡 的 最少 删除次数。
示例 1：
输入：s = "aababbab" 输出：2 解释：你可以选择以下任意一种方案： 下标从 0 开始，删除第 2 和第 6 个字符（"aababbab" -> "aaabbb"）， 下标从 0 开始，删除第 3 和第 6 个字符（"aababbab" -> "aabbbb"）。
示例 2：
输入：s = "bbaaaaabb" 输出：2 解释：唯一的最优解是删除最前面两个字符。
提示：
登录
1 <= s.length <= 105s[i] 要么是 'a' 要么是 'b' 。方法一：动态规划
我们定义 $f[i]$ 表示前 $i$ 个字符中，删除最少的字符数，使得字符串平衡。初始时 $f[0]=0$。答案为 $f[n]$。
我们遍历字符串 $s$，维护变量 $b$，表示当前遍历到的位置之前的字符中，字符 $b$ 的个数。
'b'，此时不影响前 $i$ 个字符的平衡性，因此 $f[i]=f[i-1]$，然后我们更新 $b \leftarrow b+1$。'a'，此时我们可以选择删除当前字符，那么有 $f[i]=f[i-1]+1$；也可以选择删除之前的字符 $b$，那么有 $f[i]=b$。因此我们取两者的最小值，即 $f[i]=\min(f[i-1]+1,b)$。综上，我们可以得到状态转移方程：
$$
f[i]=\begin{cases}
f[i-1], & s[i-1]='b'\
\min(f[i-1]+1,b), & s[i-1]='a'
\end{cases}
$$
最终答案为 $f[n]$。
class Solution:
def minimumDeletions(self, s: str) -> int:
n = len(s)
f = [0] * (n + 1)
b = 0
for i, c in enumerate(s, 1):
if c == 'b':
f[i] = f[i - 1]
b += 1
else:
f[i] = min(f[i - 1] + 1, b)
return f[n]
class Solution {
public int minimumDeletions(String s) {
int n = s.length();
int[] f = new int[n + 1];
int b = 0;
for (int i = 1; i <= n; ++i) {
if (s.charAt(i - 1) == 'b') {
f[i] = f[i - 1];
++b;
} else {
f[i] = Math.min(f[i - 1] + 1, b);
}
}
return f[n];
}
}
class Solution {
public:
int minimumDeletions(string s) {
int n = s.size();
int f[n + 1];
memset(f, 0, sizeof(f));
int b = 0;
for (int i = 1; i <= n; ++i) {
if (s[i - 1] == 'b') {
f[i] = f[i - 1];
++b;
} else {
f[i] = min(f[i - 1] + 1, b);
}
}
return f[n];
}
};
func minimumDeletions(s string) int {
n := len(s)
f := make([]int, n+1)
b := 0
for i, c := range s {
i++
if c == 'b' {
f[i] = f[i-1]
b++
} else {
f[i] = min(f[i-1]+1, b)
}
}
return f[n]
}
func min(a, b int) int {
if a < b {
return a
}
return b
}
function minimumDeletions(s: string): number {
const n = s.length;
const f = new Array(n + 1).fill(0);
let b = 0;
for (let i = 1; i <= n; ++i) {
if (s.charAt(i - 1) === 'b') {
f[i] = f[i - 1];
++b;
} else {
f[i] = Math.min(f[i - 1] + 1, b);
}
}
return f[n];
}
我们注意到，状态转移方程中只与前一个状态以及变量 $b$ 有关，因此我们可以仅用一个答案变量 $ans$ 维护当前的 $f[i]$，并不需要开辟数组 $f$。
class Solution:
def minimumDeletions(self, s: str) -> int:
ans = b = 0
for c in s:
if c == 'b':
b += 1
else:
ans = min(ans + 1, b)
return ans
class Solution {
public int minimumDeletions(String s) {
int n = s.length();
int ans = 0, b = 0;
for (int i = 0; i < n; ++i) {
if (s.charAt(i) == 'b') {
++b;
} else {
ans = Math.min(ans + 1, b);
}
}
return ans;
}
}
class Solution {
public:
int minimumDeletions(string s) {
int ans = 0, b = 0;
for (char& c : s) {
if (c == 'b') {
++b;
} else {
ans = min(ans + 1, b);
}
}
return ans;
}
};
func minimumDeletions(s string) int {
ans, b := 0, 0
for _, c := range s {
if c == 'b' {
b++
} else {
ans = min(ans+1, b)
}
}
return ans
}
func min(a, b int) int {
if a < b {
return a
}
return b
}
function minimumDeletions(s: string): number {
const n = s.length;
let ans = 0,
b = 0;
for (let i = 0; i < n; ++i) {
if (s.charAt(i) === 'b') {
++b;
} else {
ans = Math.min(ans + 1, b);
}
}
return ans;
}
时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串 $s$ 的长度。
方法二：枚举 + 前缀和
我们可以枚举字符串 $s$ 中的每一个位置 $i$，将字符串 $s$ 分成两部分，分别为 $s[0,..,i-1]$ 和 $s[i+1,..n-1]$，要使得字符串平衡，我们在当前位置 $i$ 需要删除的字符数为 $s[0,..,i-1]$ 中字符 $b$ 的个数加上 $s[i+1,..n-1]$ 中字符 $a$ 的个数。
因此，我们维护两个变量 $lb$ 和 $ra$ 分别表示 $s[0,..,i-1]$ 中字符 $b$ 的个数以及 $s[i+1,..n-1]$ 中字符 $a$ 的个数，那么我们需要删除的字符数为 $lb+ra$。枚举过程中，更新变量 $lb$ 和 $ra$。
class Solution:
def minimumDeletions(self, s: str) -> int:
lb, ra = 0, s.count('a')
ans = len(s)
for c in s:
ra -= c == 'a'
ans = min(ans, lb + ra)
lb += c == 'b'
return ans
class Solution {
public int minimumDeletions(String s) {
int lb = 0, ra = 0;
int n = s.length();
for (int i = 0; i < n; ++i) {
if (s.charAt(i) == 'a') {
++ra;
}
}
int ans = n;
for (int i = 0; i < n; ++i) {
ra -= (s.charAt(i) == 'a' ? 1 : 0);
ans = Math.min(ans, lb + ra);
lb += (s.charAt(i) == 'b' ? 1 : 0);
}
return ans;
}
}
class Solution {
public:
int minimumDeletions(string s) {
int lb = 0, ra = count(s.begin(), s.end(), 'a');
int ans = ra;
for (char& c : s) {
ra -= c == 'a';
ans = min(ans, lb + ra);
lb += c == 'b';
}
return ans;
}
};
func minimumDeletions(s string) int {
lb, ra := 0, strings.Count(s, "a")
ans := ra
for _, c := range s {
if c == 'a' {
ra--
}
if t := lb + ra; ans > t {
ans = t
}
if c == 'b' {
lb++
}
}
return ans
}
function minimumDeletions(s: string): number {
let lb = 0,
ra = 0;
const n = s.length;
for (let i = 0; i < n; ++i) {
if (s.charAt(i) === 'a') {
++ra;
}
}
let ans = n;
for (let i = 0; i < n; ++i) {
ra -= s.charAt(i) === 'a' ? 1 : 0;
ans = Math.min(ans, lb + ra);
lb += s.charAt(i) === 'b' ? 1 : 0;
}
return ans;
}
时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串 $s$ 的长度。
有任何问题，欢迎评论区交流，欢迎评论区提供其它解题思路（代码），也可以点个赞支持一下作者哈😄~
问：为什么把 if-else 写成 (c - 'a') * 2 - 1 就会快很多？
答：CPU 在遇到分支（条件跳转指令）时会预测代码要执行哪个分支，如果预测正确，CPU 就会继续按照预测的路径执行程序。但如果预测失败，CPU 就需要回滚之前的指令并加载正确的指令，以确保程序执行的正确性。
对于本题的数据，字符 $\text{a'}$ 和 $\text{b'}$ 可以认为是随机出现的，在这种情况下分支预测就会有 $50%$ 的概率失败。失败导致的回滚和加载操作需要消耗额外的 CPU 周期，如果能用较小的代价去掉分支，对于本题的情况必然可以带来效率上的提升。
注意：这种优化方法往往会降低可读性，最好不要在业务代码中使用。
class Solution:
def minimumDeletions(self, s: str) -> int:
ans = delete = s.count('a')
for c in s:
delete -= 1 if c == 'a' else -1
if delete < ans: # 手动 min 会快很多
ans = delete
return ans
class Solution {
public int minimumDeletions(String S) {
var s = S.toCharArray();
int del = 0;
for (var c : s)
del += 'b' - c; // 统计 'a' 的个数
int ans = del;
for (var c : s) {
// 'a' -> -1 'b' -> 1
del += (c - 'a') * 2 - 1;
ans = Math.min(ans, del);
}
return ans;
}
}
class Solution {
public:
int minimumDeletions(string s) {
int del = 0;
for (char c : s)
del += 'b' - c; // 统计 'a' 的个数
int ans = del;
for (char c : s) {
// 'a' -> -1 'b' -> 1
del += (c - 'a') * 2 - 1;
ans = min(ans, del);
}
return ans;
}
};
func minimumDeletions(s string) int {
del := strings.Count(s, "a")
ans := del
for _, c := range s {
// 'a' -> -1 'b' -> 1
del += int((c-'a')*2 - 1)
if del < ans {
ans = del
}
}
return ans
}
如果你还不熟悉动态规划（包括空间优化），可以先看看 动态规划入门。
考虑 $s$ 的最后一个字母：
设 $\textit{cntB}$ 为前 $i$ 个字母中 $\text{`b'}$ 的个数。定义 $f[i]$ 表示使 $s$ 的前 $i$ 个字母平衡的最少删除次数：
代码实现时，可以只用一个变量表示 $f$。
问：这一次遍历怎么没两次遍历快啊？
答：方法一解释了。通过这两种方法的对比，相信你能感受到随机数据对分支预测的影响。
class Solution:
def minimumDeletions(self, s: str) -> int:
f = cnt_b = 0
for c in s:
if c == 'b': cnt_b += 1 # f 值不变
else: f = min(f + 1, cnt_b)
return f
class Solution {
public int minimumDeletions(String s) {
int f = 0, cntB = 0;
for (char c : s.toCharArray())
if (c == 'b') ++cntB; // f 值不变
else f = Math.min(f + 1, cntB);
return f;
}
}
class Solution {
public:
int minimumDeletions(string s) {
int f = 0, cnt_b = 0;
for (char c : s)
if (c == 'b') ++cnt_b; // f 值不变
else f = min(f + 1, cnt_b);
return f;
}
};
func minimumDeletions(s string) int {
f, cntB := 0, 0
for _, c := range s {
if c == 'b' { // f 值不变
cntB++
} else {
f = min(f+1, cntB)
}
}
return f
}
func min(a, b int) int { if b < a { return b }; return a }
附：我的 每日一题·高质量题解精选，已分类整理好。
欢迎关注【biIibiIi@灵茶山艾府】，高质量算法教学，持续更新中~
思路
通过删除部分字符串，使得字符串达到下列三种情况之一，即为平衡状态：
a''}$ 也有 $\text{b''}$，且所有 $\text{a''}$ 都在所有 $\text{b''}$ 左侧。其中，为了达到第 $1$ 种情况，最少需要删除所有的 $\text{b''}$。为了达到第 $2$ 种情况，最少需要删除所有的 $\text{a''}$。而第 $3$ 种情况，可以在原字符串相邻的两个字符之间划一条间隔，删除间隔左侧所有的 $\text{b''}$ 和间隔右侧所有的 $\text{a''}$ 即可达到。用 $\textit{leftb}$ 表示间隔左侧的 $\text{b''}$ 的数目，$\textit{righta}$ 表示间隔左侧的 $\text{a''}$ 的数目，$\textit{leftb}+\textit{righta}$ 即为当前划分的间隔下最少需要删除的字符数。这样的间隔一共有 $n-1$ 种，其中 $n$ 是 $s$ 的长度。遍历字符串 $s$，即可以遍历 $n-1$ 种间隔，同时更新 $\textit{leftb}$ 和 $\textit{righta}$ 的数目。而上文讨论的前两种情况，其实就是间隔位于首字符前和末字符后的两种特殊情况，可以加入第 $3$ 种情况一并计算。
代码
###Python
class Solution:
def minimumDeletions(self, s: str) -> int:
leftb, righta = 0, s.count('a')
res = righta
for c in s:
if c == 'a':
righta -= 1
else:
leftb += 1
res = min(res, leftb + righta)
return res
###Java
class Solution {
public int minimumDeletions(String s) {
int leftb = 0, righta = 0;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == 'a') {
righta++;
}
}
int res = righta;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == 'a') {
righta--;
} else {
leftb++;
}
res = Math.min(res, leftb + righta);
}
return res;
}
}
###C#
public class Solution {
public int MinimumDeletions(string s) {
int leftb = 0, righta = 0;
foreach (char c in s) {
if (c == 'a') {
righta++;
}
}
int res = righta;
foreach (char c in s) {
if (c == 'a') {
righta--;
} else {
leftb++;
}
res = Math.Min(res, leftb + righta);
}
return res;
}
}
###C++
class Solution {
public:
int minimumDeletions(string s) {
int leftb = 0, righta = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'a') {
righta++;
}
}
int res = righta;
for (int i = 0; i < s.size(); i++) {
char c = s[i];
if (c == 'a') {
righta--;
} else {
leftb++;
}
res = min(res, leftb + righta);
}
return res;
}
};
###C
#define MIN(a, b) ((a) < (b) ? (a) : (b))
int minimumDeletions(char * s) {
int len = strlen(s);
int leftb = 0, righta = 0;
for (int i = 0; i < len; i++) {
if (s[i] == 'a') {
righta++;
}
}
int res = righta;
for (int i = 0; i < len; i++) {
char c = s[i];
if (c == 'a') {
righta--;
} else {
leftb++;
}
res = MIN(res, leftb + righta);
}
return res;
}
###JavaScript
var minimumDeletions = function(s) {
let leftb = 0, righta = 0;
for (let i = 0; i < s.length; i++) {
if (s[i] === 'a') {
righta++;
}
}
let res = righta;
for (let i = 0; i < s.length; i++) {
const c = s[i];
if (c === 'a') {
righta--;
} else {
leftb++;
}
res = Math.min(res, leftb + righta);
}
return res;
};
###go
func minimumDeletions(s string) int {
leftb := 0
righta := 0
for _, c := range s {
if c == 'a' {
righta++
}
}
res := righta
for _, c := range s {
if c == 'a' {
righta--
} else {
leftb++
}
res = min(res, leftb+righta)
}
return res
}
func min(a, b int) int {
if a > b {
return b
}
return a
}
复杂度分析
时间复杂度：$O(n)$，其中 $n$ 是 $s$ 的长度。需要遍历两遍 $s$，第一遍计算出 $s$ 中 $\text{``a''}$ 的数量，第二遍遍历所有的间隔，求出最小需要删除的字符数。
空间复杂度：$O(1)$，只需要常数空间。
"写个代码" "帮我写个快速排序函数，用 Python 实现，要求时间复杂度 O(n log n)，添加详细注释"
同样是让 AI 写代码，为什么第一个指令得到的是模糊的回复，而第二个能得到精确满足需求的代码？
这就是提示词工程（Prompt Engineering）的魔力。
好的 Prompt = 好的输出。今天我们来学习如何写出让 AI "秒懂"的提示词。
提示词（Prompt）：你给大模型的输入指令
提示词工程（Prompt Engineering）：设计和优化 Prompt 的艺术和科学
┌─────────────────────────────────────────┐
│ Prompt 结构模板 │
├─────────────────────────────────────────┤
│ │
│ 1. 角色（Role） │
│ "你是一个经验丰富的程序员..." │
│ │
│ 2. 任务（Task） │
│ "请写一个快速排序函数..." │
│ │
│ 3. 上下文（Context） │
│ "用于处理整数数组..." │
│ │
│ 4. 约束（Constraints） │
│ "要求O(n log n)时间复杂度..." │
│ │
│ 5. 格式（Format） │
│ "返回JSON格式，包含code和说明..." │
│ │
│ 6. 示例（Examples） │
│ "输入:[3,1,2] 输出:[1,2,3]" │
│ │
└─────────────────────────────────────────┘
❌ 没有角色：
"怎么提高编程能力？"
✅ 有角色：
"你是一位有10年经验的编程导师，
曾经指导过数百名初学者成为资深工程师。
请给我提供提高编程能力的建议。"
效果差异：有角色的 Prompt 能得到更有针对性、更有深度的回答。
❌ 模糊的任务：
"帮我写个文章"
✅ 明确的任务：
"请写一篇关于人工智能发展历史的文章，
要求：
1. 字数800-1000字
2. 包含三个主要发展阶段
3. 提到GPT、Llama等关键模型
4. 语言风格通俗易懂"
SMART 原则：
❌ 缺少上下文：
"这个代码有什么问题？"
[粘贴一段代码]
✅ 充足上下文：
"我正在开发一个电商网站的用户认证功能。
这段Python代码用于验证用户密码，
但总是返回False，帮我找出问题：
[粘贴代码]
预期行为：正确密码返回True，错误密码返回False
实际行为：所有密码都返回False"
上下文要素清单：
少样本学习示例：
例子1：
输入：苹果
分类：水果
例子2：
胡萝卜
分类：蔬菜
例子3：
香蕉
分类：？
思维链示例：
问题：小明有5个苹果，吃了2个，又买了3个，现在有几个？
思考过程：
1. 初始：小明有5个苹果
2. 吃了2个：5 - 2 = 3个
3. 买了3个：3 + 3 = 6个
答案：6个
现在请解决：
小红有10颗糖，给了妹妹3颗，妈妈又给了她5颗，现在有几颗？
效果：示例能让 AI 快速理解你想要的输出模式。
❌ 不好的 Prompt：
"分析这段代码"
✅ 好的 Prompt：
"请分析以下代码，并按以下格式输出：
## 代码功能
[简要说明代码的功能]
## 时间复杂度
[分析时间复杂度]
## 改进建议
[列出3条具体改进建议]
## 重构代码
\`\`\`python
[重构后的代码]
\`\`\`"
代码生成模板：
你是一个{语言}专家。
请写一个{功能描述}的{语言}函数，
要求：
1. {要求1}
2. {要求2}
3. {要求3}
请包含：
- 详细的注释
- 错误处理
- 使用示例
Bug 调试模板：
我在开发一个{项目类型}项目，
这段{语言}代码出现了{问题描述}：
\`\`\`{语言}
{代码}
\`\`\`
预期行为：{预期}
实际行为：{实际}
请帮我：
1. 找出问题所在
2. 解释问题原因
3. 提供修复方案
| 技巧 | 说明 | 示例 |
|---|---|---|
| 明确角色 | 给 AI 分配身份 | "你是一位经验丰富的程序员" |
| 具体任务 | 清楚说明要做什么 | "写一个快速排序，O(n log n)" |
| 充足上下文 | 提供背景信息 | "这是电商网站的推荐功能" |
| 使用示例 | 展示期望格式 | "输入A输出B，输入C输出？" |
| 明确格式 | 说明输出形式 | "以 JSON 格式返回" |
发送 Prompt 前，问自己：
| 陷阱 | 问题 | 解决方案 |
|---|---|---|
| 过于简短 | "帮我优化代码" | 说明具体优化目标 |
| 矛盾要求 | "性能最好但代码简洁" | 明确优先级 |
| 一次太多 | "写完整电商系统" | 分解为小任务 |
| 缺少验证 | "计算复杂数学" | 要求给出计算步骤 |
1. 迭代优化
第一次尝试 → 评估结果 → 修改 Prompt → 再次尝试
2. 温度参数调整
3. 分解复杂任务
"设计一个博客系统"
↓ 分解为
"1. 设计数据库结构"
"2. 设计用户认证 API"
"3. 设计文章发布 API"
GPT-4、Claude、Llama、Qwen、DeepSeek...
面对层出不穷的大语言模型，你是否也曾感到迷茫？
选对模型，不仅能节省成本，还能获得更好的效果。今天我们来聊聊如何做出明智的选择。
| 特点 | 闭源模型 | 开源模型 |
|---|---|---|
| 代表 | GPT-4、Claude、Gemini | Llama、Qwen、DeepSeek |
| 性能 | 性能最强 | 快速追赶中 |
| 成本 | 价格昂贵 | 免费或低价 |
| 部署 | 仅云端 | 可本地部署 |
| 隐私 | 数据上传云端 | 完全私密 |
| 定制 | 难以定制 | 高度可定制 |
| 指标 | 说明 |
|---|---|
| 参数量 | 模型规模，通常越大越强 |
| 上下文长度 | 能处理的文本长度 |
| 推理能力 | 逻辑思考和问题解决能力 |
| 中文能力 | 对中文的理解和生成质量 |
| API 价格 | 每 1M tokens 的费用 |
| 模型 | 核心优势 | 价格 | 最佳场景 |
|---|---|---|---|
| GPT-4o | 综合能力最强 | $5/1M 输入 | 复杂任务、多模态 |
| Claude 3.5 Sonnet | 长文本、推理强 | $3/1M 输入 | 编程、写作 |
| Gemini 1.5 Pro | 超长上下文(1M) | 按用量计费 | 视频、长文档处理 |
选型建议：追求极致性能时选择闭源模型。
| 模型 | 参数量 | 核心优势 | 硬件要求 | 最佳场景 |
|---|---|---|---|---|
| Qwen2.5 7B | 70亿 | 中文优秀 | 6GB 显存 | 中文本地部署 |
| Llama 3.1 8B | 80亿 | 通用平衡 | 8GB 显存 | 英文场景 |
| DeepSeek-V3 | 680亿 | 性价比之王 | 24GB 显存 | 编程任务 |
| GLM-4 9B | 90亿 | 国产化 | 6GB 显存 | 企业应用 |
选型建议：预算有限或关注隐私时选择开源模型。
场景 1：中文日常对话
推荐：Qwen2.5 7B 或 DeepSeek-V3
原因：
- 中文能力强
- API 价格低（¥1/1M 输入）
- 响应速度快
场景 2：代码生成
推荐：DeepSeek-V3 或 Claude 3.5 Sonnet
原因：
- 代码质量高
- 理解上下文能力强
- 调试能力出色
场景 3：长文档处理
推荐：Claude 3 或 Gemini 1.5 Pro
原因：
- 支持 200K-1M tokens 上下文
- 总结能力强
- 细节保留好
场景 4：本地部署
推荐：Qwen2.5 7B (INT4 量化)
原因：
- 显存需求低（~4GB）
- 中文优化好
- 性能接近 GPT-3.5
云端 API 价格对比（1M tokens）：
| 模型 | 输入价格 | 输出价格 | 性价比评级 |
|---|---|---|---|
| DeepSeek-V3 | ¥1 | ¥2 | ⭐⭐⭐⭐⭐ |
| Qwen-turbo | ¥0.8 | ¥2 | ⭐⭐⭐⭐⭐ |
| GPT-4o | $5 | $15 | ⭐⭐ |
| Claude 3.5 | $3 | $15 | ⭐⭐ |
结论：DeepSeek 和 Qwen 性价比最高。
| 配置 | 硬件成本 | 月电费 | 年总成本 | 何时回本 |
|---|---|---|---|---|
| Qwen2.5 7B | ¥3000 | ¥50 | ¥3600 | 使用 > 1 年 |
| Qwen2.5 14B | ¥6000 | ¥80 | ¥6960 | 使用 > 1.5 年 |
结论：长期使用（>1年），本地部署更划算。
当用户习惯在小红书寻找美妆产品和穿搭套装时，一场助农直播，正悄然拓宽这个平台的电商叙事。
没有倒计时、没有急促的叫卖，也没有歇斯底里的“上链接”，四川籍演员赵露思化身“助农推荐官”，在直播间内边吃边聊，细细讲解来自家乡山野的青川竹荪、汉源花椒和黑美人蜜薯等农产品。
这场助农直播契合了小红书社区的底色：真实分享、生活气息、信任联结。正是在这种氛围中，“卖货”成了“分享好生活”的自然延伸。
数据证明，这场直播背后蕴含着巨大的商业爆发力。36氪获悉，这场直播吸引了近900万用户观看，最终售出农产品超过82万单，其中包括1159吨生鲜水果和40余万件农副产品。
从美妆到蜜薯的跨越，证明小红书电商可能性远不止服饰美妆，生鲜农产品只是一个开端。
这场助农直播，正是小红书下一阶段的成长逻辑：以内容信任为基石，以真诚分享为桥梁，进化为一个涵盖生鲜农产品、地方好物等全品类的生活方式电商平台。
过去，在小红书的直播带货江湖里，美妆、服饰是绝对主角，成为用户对平台的固有印象。
但近期一场大型农产品直播，刷新了所有人的认知。1月28日，小红书推出助农直播，发起一场“商家0服务费、买手0服务费、明星0佣金”的三零佣金的助农直播。
这次，小红书把汉源花椒、凉山古法红糖、泸州黄粑等“土味”山货搬到了直播间，令人出乎意料的是，直播过程中多款产品数次补货仍被抢空。
为什么小红书初次试水农产品直播，就能做到单场82万单的成绩？为什么藏于深山的农货能在小红书快速出圈？
首先，通过零佣金、零服务费模式，平台成功将利润空间最大限度地返还给了源头生产者，让好产品自己说话，从而激发源头商家以极致品质和诚意参与选品竞争，在源头确保了产品品质。
90后新农人李焕平带着他的汉源花椒走进了直播间。自从返乡创业后，他坚持收购核心产区树龄合适的“正路南椒”，并引入先进技术将花椒开口率提升至95%以上、杂质率压至0.1%以下，甚至开发出椒麻酱、驱虫香囊等适配年轻人市场的创新单品。
在直播间的深度分享下，这款“千年贡椒”迅速击中年轻消费者的心，一度引发网友感叹：“原来还有这样我不知道的四川好花椒。”
来自四川凉山州的创业者舒发军，则与残疾伙伴团队坚守古法，用五口柴火大锅24小时慢熬高山川蔗汁。这份承载着匠心的古法红糖，转化为了实实在在的购买力，单场售出近8万斤。
其他农产品也一售而空。宜宾黄粑在直播间几度售罄补货，最终销量突破100万块，黑美人蜜薯与榴莲紫薯累计售出超18万斤；眉山大橘甘平累计卖出4万余斤……
更值得关注的是，直播后越来越多消费者开始在小红书搜索、购买农产品，足见小红书平台已成功撬动平台消费者的生鲜消费需求。
从美妆、服饰到生鲜农货，小红书用一场助农直播证明，其电商边界远未定型。这场直播的成果，不仅为小红书打开了涵盖地方风物、特色食品在内的广阔品类增长空间，更让小红书的电商货架，变得前所未有的丰富与厚重。
当从大山里走出来的牛油果在小红书直播间被抢购一空，单场6400单的销量相当于农户960个小时的常规努力，以及黑美人蜜薯与榴莲紫薯累计售出超18万斤时，一个认知已然清晰：小红书电商生态的广度正在被刷新。
这不仅是一场销售端的胜利，更是一次认知维度的颠覆。小红书打破了“优质牛油果必属进口”的固有消费认知，证明了在小红书的内容场域，有能力让最“土”的源头好货，也能展现惊人的消费爆发力 。
为什么“土味好货”也能在小红书出圈？这个问题的答案，根植于小红书与众不同的平台基因与运营逻辑。
首先，真诚分享的社区氛围构成了信任的基石。小红书的底层逻辑是“真实体验、真诚分享”，用户早已习惯在此寻找真实的体验与分享内容。
在这里，一篇真正优质的分享内容会成为“自来水”，收获自然流量与真诚赞誉；反之，任何夸大或虚假的内容也难逃用户雪亮的眼睛，会被直接质疑吐槽，并迅速被标记为避雷帖子。
这种真实透明的社区生态，使得平台上的信息经过了一层天然的过滤与背书。因此，在直播间里，当产地实景、实时试吃与真实讲解现场呈现时，这种无滤镜的信任氛围，成为农货销售的坚实基础，让消费者敢于尝试陌生的地方特产。
此时，小红书构建起的社区信任氛围，成为了陌生产品成交的“基础设施”。消费者在这里购买的，不止是商品，更是一份经过社区验证的、关于“好产品”的承诺。
其次，区别于传统电商“叫卖式”的快节奏带货，小红书的助农直播更像一场沉浸式的“唠嗑”。
助农推荐官赵露思以生活化的分享方式，娓娓道来产品背后的故事。例如从汉源花椒的种植培育，到90后新农人李焕平的创业历程；从24小时柴火慢熬的古法红糖，到舒发军团队背后残疾伙伴的奋斗故事。
这种深挖每款农货背后的生长密码与人文故事，让冰冷的商品有了温度，也让每款农货的价值叙事得以完整展开，使得消费者在情感共鸣中完成消费决策。他们买的不仅是一粒花椒、一颗红糖，也是对一种认真生活态度的认同，更是一份支持匠心与家乡的情怀。
最终，这一切都服务于一个核心：让好产品真正被看见。小红书独特的算法推荐与活跃的内容生态，像一台精准的放大器，将原本藏于深山、缺乏曝光的地方特色产品，借助一场直播推向全国市场。
比如泸州黄粑，自从宣布进入直播间后便成为全网热点，直播中两度售罄补货，累计售出100多万块，让地方特色小吃真正走出了当地，卖向全国市场。
这场直播的爆款农货，只是小红书地方风味好货版图的冰山一角。在平台上，还有无数扎根各地的优质农货商家在持续深耕，天南地北的地方风味好货齐聚于此，丰富的供给让每一种地域美味都有了被看见的机会。
也因此，小红书的助农实践，意义远不止于为商户们增加一个销售渠道。它通过“真诚分享”与“真实评价”的独特路径，放大了农产品本身的价值，让好东西不仅能卖出去，更能卖爆、卖出好价。
在这里，好产品不必陷入低价的恶性竞争，而是凭借真实的品质、动人的故事和可追溯的源头，赢得应有的市场地位与价格尊重。
82万单农产品售罄的成绩，是一个清晰的起点。
36氪获悉，小红书已将助农直播列为全年持续行动，未来将走进更多省市县，系统性挖掘和推广各地的“隐藏好货”，将这一模式推向常态化，让大山深处的优质农产品能够批量化地走向全国人民的餐桌
这背后的深层意义，远不止于单场销售的胜利，而是建立起长效助农机制，真正“授人以渔”。
为什么小红书能做成助农直播这件“难而正确”的事？答案藏在直播结束后持续释放的长效外溢效应中。
对于参与商家而言，直播引爆的瞬时销量固然惊喜，但更具价值的是持续的资产沉淀。数据显示，宜宾黄粑、眉山大橘甘平等爆款产品在直播后的站内搜索量分别同比激增353%和202%。
这意味着，海量被直播吸引来的消费者，转化为了品牌的主动搜索者与店铺的长期粉丝。
就此，一个由直播引爆，到店铺沉淀，最终持续复购的完整消费闭环已然形成。在小红书，商家获得的不是一锤子买卖，而是一个能收获稳定复购客群、持续生长的线上阵地。
从平台生态的视角看，此次助农直播的成功，验证了小红书在生鲜非标品领域的电商硬实力。
长期以来，生鲜农产品因品质不均、物流复杂等问题，被视为电商经营的“硬骨头”，但小红书凭借“政府推荐+平台把关”的品控机制，以及“真实分享”的社区基因，成功破解了信任难题。
更重要的是，小红书释放了一个强烈而清晰的信号，小红书的“种草-直播-转化-沉淀”生态足够完整高效，且具备极强的跨品类迁移能力。无论是美妆、服饰，还是家居、食品等品类，都能在这里通过内容与用户建立深度连接，同时实现品牌曝光与销售，开辟新的生意增长路径。
这场助农直播最大的启示在于，小红书正成为好产品与消费者的有效“连接器”。它不创造产品，但擅长发现和放大产品的内在价值；它不生产内容，但构建了让真诚分享得以传播的优质土壤。
对于无数渴望被看见的“好产品”而言，小红书提供的不仅是一个销售渠道，更是一条绕过低价竞争、直达价值认同的品牌捷径，因为在这里不靠极端的低价竞争，而是通过价值放大，让好产品卖出应有的价值。
这或许是小红书，正在创造的最具颠覆性的商业价值。
想象你拿着一部手机摄像头对着一个房间：
透视相机就像真实的摄像头一样，离物体越近，看到的范围越小；离物体越远，看到的范围越大。这就是"透视"的含义。
import * as THREE from 'three';
// 创建透视相机
const camera = new THREE.PerspectiveCamera(
40, // 视野角度（FOV）
2, // 宽高比（aspect ratio）(一般3D游戏中的屏幕适配都是在调整这个值）
0.1, // 近裁剪面（near）
1000 // 远裁剪面（far）
);
camera.position.z = 120; // 相机位置
定义：相机能看到的垂直视角范围，单位是度数（°）。
直观理解：
// 小视角 - 看得清楚但范围小
const camera1 = new THREE.PerspectiveCamera(20, 2, 0.1, 1000);
// 中等视角 - 平衡
const camera2 = new THREE.PerspectiveCamera(40, 2, 0.1, 1000);
// 大视角 - 看得多但容易变形
const camera3 = new THREE.PerspectiveCamera(75, 2, 0.1, 1000);
实际应用：
定义：相机画面的宽度与高度的比例。
计算方式：
const aspect = window.innerWidth / window.innerHeight;
// 例如：1920 / 1080 = 1.777...
为什么重要？
// 假设窗口是 1920×1080
const aspect = 1920 / 1080; // ≈ 1.78
const camera = new THREE.PerspectiveCamera(40, aspect, 0.1, 1000);
响应式设计：
function onWindowResize() {
const width = window.innerWidth;
const height = window.innerHeight;
camera.aspect = width / height;
camera.updateProjectionMatrix(); // 重要！更新投影矩阵
renderer.setSize(width, height);
}
window.addEventListener('resize', onWindowResize);
定义：相机能看到的最近距离。比这个距离更近的物体不会被显示。
为什么需要它？
// near = 0.1 意味着距离相机 0.1 单位以内的物体看不到
const camera = new THREE.PerspectiveCamera(40, 2, 0.1, 1000);
// 如果物体在 z = 0.05，它会被裁剪掉
const cube = new THREE.Mesh(geometry, material);
cube.position.z = 0.05; // ❌ 看不到
定义：相机能看到的最远距离。比这个距离更远的物体不会被显示。
为什么需要它？
// far = 1000 意味着距离相机 1000 单位以外的物体看不到
const camera = new THREE.PerspectiveCamera(40, 2, 0.1, 1000);
// 如果物体在 z = 1500，它会被裁剪掉
const star = new THREE.Mesh(geometry, material);
star.position.z = 1500; // ❌ 看不到
视锥体是一个四棱锥形的空间，只有在这个空间内的物体才能被看到。
在距离相机 distance 处，可视范围的大小为：
垂直高度 = 2 × tan(FOV/2) × distance
水平宽度 = 垂直高度 × aspect
假设我们有这样的相机配置：
const fov = 40; // 视野角度
const aspect = 2; // 宽高比（2:1）
const distance = 120; // 相机距离（z = 120）
// 计算垂直可视高度
const vFOV = fov * Math.PI / 180; // 转换为弧度
const height = 2 * Math.tan(vFOV / 2) * distance;
// height = 2 × tan(20°) × 120
// height = 2 × 0.364 × 120
// height ≈ 87.2
// 计算水平可视宽度
const width = height * aspect;
// width = 87.2 × 2
// width ≈ 174.4
结论：在 z=120 处，相机能看到的范围是：
假设我们要在场景中放置一个 5×4 的网格（5列 4行），每个物体之间间距为 15 单位：
const spread = 15; // 间距
// 物体位置计算
for (let x = -2; x <= 2; x++) {
for (let y = -1; y <= 2; y++) {
const obj = createObject();
obj.position.x = x * spread; // x: -30, -15, 0, 15, 30
obj.position.y = y * spread; // y: -15, 0, 15, 30
scene.add(obj);
}
}
对象分布范围：
// 相机可视范围
const visibleWidth = 174.4;
const visibleHeight = 87.2;
// 对象范围
const objectWidth = 60;
const objectHeight = 45;
// 检查
console.log(`宽度是否超出: ${objectWidth > visibleWidth}`); // false ✅
console.log(`高度是否超出: ${objectHeight > visibleHeight}`); // false ✅
问题：当 spread=20 时，对象范围变为 80×60，超出了可视范围。
解决方案：
// 原来
camera.position.z = 120;
// 改为
camera.position.z = 160; // 距离越远，看到的范围越大
// 原来
const fov = 40;
// 改为
const fov = 60; // 视角越大，看到的范围越大
// 原来
const spread = 20;
// 改为
const spread = 15; // 物体靠得更近
如果你不需要透视效果，可以使用正交相机（OrthographicCamera），它的可视范围不会随距离变化：
const camera = new THREE.OrthographicCamera(
-100, // left
100, // right
50, // top
-50, // bottom
0.1, // near
1000 // far
);
import * as THREE from 'three';
class ResponsiveCamera {
constructor() {
this.fov = 40;
this.near = 0.1;
this.far = 1000;
this.distance = 120;
this.updateCamera();
}
updateCamera() {
const aspect = window.innerWidth / window.innerHeight;
this.camera = new THREE.PerspectiveCamera(
this.fov,
aspect,
this.near,
this.far
);
this.camera.position.z = this.distance;
}
// 计算指定深度处的可视范围
getVisibleRange(depth = null) {
const vFOV = (this.fov * Math.PI) / 180;
// 如果没有指定深度，使用相机的默认距离
const distance = depth !== null ? depth : this.distance;
const height = 2 * Math.tan(vFOV / 2) * distance;
const width = height * (window.innerWidth / window.innerHeight);
return { width, height };
}
// 检查物体是否在可视范围内
isObjectVisible(obj) {
const pos = obj.position;
// 计算物体相对于相机的距离（沿着相机的视线方向）
const distanceFromCamera = this.camera.position.z - pos.z;
// 计算物体所在深度的可视范围
const range = this.getVisibleRange(distanceFromCamera);
console.log('物体距离相机:', distanceFromCamera, '该深度的可视范围:', range);
return (
Math.abs(pos.x) <= range.width / 2 &&
Math.abs(pos.y) <= range.height / 2 &&
distanceFromCamera >= this.near &&
distanceFromCamera <= this.far
);
}
// 窗口大小改变时更新
onWindowResize() {
this.updateCamera();
this.camera.updateProjectionMatrix();
}
}
// 使用示例
// 使用示例
const scene = new THREE.Scene();
scene.background = new THREE.Color(0x222222);
// 4. 创建渲染器：将3D场景渲染到网页上
const renderer = new THREE.WebGLRenderer({ antialias: true }); // antialias开启抗锯齿
renderer.setSize(window.innerWidth, window.innerHeight); // 设置渲染尺寸
// 将渲染器的画布添加到网页中
document.body.appendChild(renderer.domElement);
const camera = new ResponsiveCamera();
window.addEventListener('resize', () => camera.onWindowResize());
// 添加光源
const ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
scene.add(ambientLight);
const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
directionalLight.position.set(50, 50, 50);
scene.add(directionalLight);
// 检查物体是否可见
const cube = new THREE.Mesh(new THREE.BoxGeometry(8, 8, 8), createMaterial());
cube.position.set(20, 20, -10);
scene.add(cube);
function animate(time) {
renderer.render(scene, camera.getCamera());
requestAnimationFrame(animate);
}
requestAnimationFrame(animate);
console.log(camera.isObjectVisible(cube)); // true or false
FOV 和 distance 决定可视范围
aspect 必须与画布比例一致
near 和 far 定义了深度范围
📂 核心代码与完整示例： my-three-app
如果你喜欢本教程，记得点赞+收藏！关注我获取更多Three.js开发干货
崔东树：2025年中国占世界新能源车份额68.4%36氪获悉，乘联分会秘书长崔东树发文称，2025年中国新能源乘用车占世界份额68.4%，其中4季度中国新能源乘用车世界份额达到71.9%的高份额。2025年1-12月中国在世界纯电动车市场份额64.3%份额，较2024年份额微增1个点。世界新能源车渗透率总体呈现快速提升趋势，2022年已经达到13%水平，2023年达到16%，2024年达到19.5%，2025年4季度渗透率达到26.3%。2025年4季度新能源渗透率中，中国新能源渗透率达到49.3%，德国达到30%，挪威达到84%，英国36%，而美国仅有7%，日本仅有2.1%，因此世界新能源发展的不均衡性极为明显。
康泰生物：终止与阿斯利康设立合资公司的投资事项36氪获悉，康泰生物公告，公司于2026年2月6日召开第八届董事会第八次会议，审议通过了《关于终止对外投资设立合资公司的议案》。此前，公司计划与阿斯利康在北京经济技术开发区设立合资公司，注册资本预计为3.45亿元人民币，投资总额预计为约4亿美元。由于市场环境剧烈变化，行业面临比较大的下行压力，新增投资疫苗产业风险比较高，双方决定终止《经济发展合作协议》《条款清单》及对外投资设立合资公司事项。自终止生效日起，任何一方不再承担任何义务和责任。
华润三九：2025年净利润34.22亿元，同比增长1.60%36氪获悉，华润三九发布业绩快报，2025年营业总收入316.29亿元，同比增长14.53%。净利润34.22亿元，同比增长1.60%。
中金珠宝公司：将调整“中国黄金”品牌所有渠道的贵金属回购业务规则36氪获悉，中国黄金集团黄金珠宝股份有限公司发布公告，将对“中国黄金”品牌所有渠道（包括线下门店及线上渠道）的贵金属回购业务规则进行调整。自2026年2月7日起，在周六、周日及法定节假日等上海黄金交易所非交易日期间，暂停办理贵金属回购业务。自2026年2月7日起，在业务办理时间内，对回购业务实施限额管理，包括但不限于单一客户单日累计回购上限、单笔回购总量上限等，并实施预约制。相关限额将根据市场情况动态调整，具体内容请以中金珠宝公司各渠道具体公告为准。
千问App免单上线9小时突破1000万订单2月6日，阿里千问App“春节30亿免单”启动，上线9个小时，用户在千问App上的AI订单突破1000万单。据了解，千问App的免单卡使用期限一直到2月23日，除了点奶茶，也可以买早中晚餐和生鲜百货，还可以通过千问App买天猫超市和线下商超的年货。
亚朵集团：亚朵4.0独立为新品牌“亚朵见野”36氪获悉，亚朵集团正式官宣亚朵酒店4.0版本独立为新品牌“亚朵见野”。公开数据显示，亚朵4.0自2023年11月产品发布后，截止2026年2月1日已在全国开业落地近50家门店，遍布30个城市，在营超3个月门店平均综合RevPAR约500元。
“卓益得机器人”完成近亿元Pre-A+轮融资
36氪获悉，近日，国内具身智能与高仿生机器人领域创新企业“卓益得机器人”宣布完成近亿元人民币Pre-A+轮融资。本轮融资由上海浦东引领区投资中心、上海张江科技创业投资有限公司联合领投，河南省科投产业发展投资基金等机构跟投，并引入青岛征和工业股份有限公司、厦门松霖科技股份有限公司集团成员作为战略产业投资者。本次募集资金将聚焦于深化核心技术与产品迭代和升级量产交付与供应链体系以及推进生态共建与市场渗透。
小米新款纯电SUV车型命名为小米YU7 GT从工信部官网披露的企业申报车型公示详情获悉，小米新款纯电SUV车型命名为小米YU7 GT。（财联社）
追觅举办“追觅之夜”，推出AI智能戒指2月4日，追觅科技在苏州举办《敢梦敢为・追觅之夜》，本次活动由央视联合主办。活动现场，追觅科技推出AI智能戒指，并邀请撒贝宁体验。据了解，这款产品搭载自研的清华AI健康算法，在睡眠分析、运动追踪和健康分析评估方面提供精准的数据解读，其核心突破在于将超微型震动马达精密嵌入仅2.5mm厚的机身。此前，该产品斩获了CES 2026 Wearable大奖。
农业农村部：加强国家种业阵型企业梯度培育，深入推进国家育种联合攻关和畜禽遗传改良计划36氪获悉，农业农村部发布关于落实《中共中央国务院关于锚定农业农村现代化扎实推进乡村全面振兴的意见》的实施意见，其中提出，深入实施种业振兴行动。加强种质资源精准鉴定和创制利用，实施农作物种质资源改良计划。加强国家种业阵型企业梯度培育，深入推进国家育种联合攻关和畜禽遗传改良计划，实施好重大品种研发推广应用一体化项目，加快选育推广高油高产大豆、耐密宜机收玉米、优质抗病小麦等突破性新品种。推进生物育种产业化。持续推进南繁硅谷、黑龙江大豆等国家育制种基地建设。开展加强品种全链条管理专项行动，加快实施实质性派生品种制度。强化种业知识产权保护，严厉打击假冒伪劣、套牌侵权等违法行为。
深交所：本周对近期股价异常波动的“嘉美包装”“锋龙股份”进行重点监控36氪获悉，深交所公告，2026年2月2日至2026年2月6日，深交所共对233起证券异常交易行为采取了自律监管措施，涉及盘中拉抬打压、虚假申报等异常交易情形；对近期股价异常波动的“嘉美包装”“锋龙股份”进行重点监控；共对8起上市公司重大事项进行核查，并上报证监会4起涉嫌违法违规案件线索。
市场监管总局公开征求推荐性国家标准《预制菜术语和分类》（征求意见稿）意见36氪获悉，国家标准《预制菜术语和分类》（征求意见稿）开始公开征求意见。近年来，预制菜产业快速发展，社会各界广泛关注，急需对预制菜产业进行科学规范和有效引导。在术语部分，共制定了20个术语，包括6个一般术语和14个工艺术语。在分类部分，主要考虑与现行食品安全相关标准法规的衔接，将预制菜从主要原料、预制工艺、贮运方式、包装方式、食用方式等不同维度进行了划分。
商务部：大力发展离境退税，推动更多商店成为退税商店商务部副部长鄢东在国务院政策例行吹风会上表示，大力发展离境退税。推动更多商店成为退税商店，进一步优化退税服务，提升便利化水平，通过扩商店、增商品、优服务，吸引境外旅客来华消费，切实激发入境消费的潜力。（中国网）
在工业和信息化部第 404 批《道路机动车辆生产企业及产品公告》中，小米 YU7 GT 正式亮相。
新车车身尺寸为长 5015 毫米、宽 2007 毫米、高 1597 毫米，轴距保持 3000 毫米不变。
相较现售 YU7 车型（长 4999mm、宽 1996mm、高 1600mm），新车长度和宽度略有增加，高度则略微降低，整体姿态更低趴，运动感显著增强。
车身细节方面，YU7 GT 取消了前后主动进气格栅（AGS）系统，同时对侧裙与轮拱造型进行微调，并新增多处空气动力学组件，使整车视觉效果更为锐利、更具赛道气质。
此外，前门板连接处与车尾均加入醒目的红色「GT」标识，进一步强调其高性能身份。
值得注意的是，此次申报车型采用黑色车漆，这一配色此前并未出现在普通版 YU7 上，黑色或将成为 GT 版本的专属或首发色系。
动力系统是 YU7 GT 的核心亮点。新车搭载由小米汽车与汇川科技联合开发的高性能双电机系统，前轴电机与 SU7 Ultra 同款，功率 288 千瓦；后轴配备峰值功率达 450 千瓦的单 V8s 电机；综合输出功率约 1004 马力，最高时速可达 300 公里/小时。
作为对比，现款 YU7 Max 的前后电机功率分别为 220 千瓦与 288 千瓦，总功率 508 千瓦（约 690 马力）。YU7 GT 的动力性能实现近乎翻倍的跃升。
为匹配其高性能定位，车辆轮胎规格同步升级，前轮为 265/40 R21，后轮为 295/35 R21，均为 21 英寸超宽胎，提供更强抓地力与操控稳定性。
YU7 GT 同时提供丰富的选装方案，包括前组合灯装饰件、碳纤维外后视镜、后扰流板、鸭尾式尾翼以及前机盖装饰件等空气动力学或视觉套件。
据多方消息，YU7 GT 已进入实车测试阶段，多次现身纽博格林北环赛道进行高强度调校。
新车将配备主动液压悬架系统，在赛道模式下可自动降低车身高度，并支持动力分配自由调节，目标直指量产 SUV 圈速纪录，充分彰显其「为赛道而生」的工程理念。
YU7 GT 主要对标特斯拉 Model Y 高性能版及保时捷 Cayenne Turbo GT 等高端性能 SUV，目标用户为高频参与赛道活动、追求极致驾驶体验的消费者。
尽管性能强悍，但综合参数判断，其整体定位仍略低于小米旗舰车型 SU7 Ultra，预计新车售价区间为 40 万至 50 万元，
小米此前凭借 SU7 Ultra 成功树立「性能科技」品牌形象，YU7 GT 的推出将进一步巩固这一战略标签，并拓展其在高性能电动产品矩阵中的布局。
除 YU7 GT 外，小米还计划于今年 4 月上市新一代 SU7，并已在规划中布局更多新车型，包括大中型家用增程 SUV YU9 和四门行政级轿车 SU7 L。
自 2024 年 4 月 3 日首款车型交付以来，小米汽车累计交付量已突破 50 万辆，并于 2025 年第三季度实现盈利。
在今年 1 月的公开直播中，小米创始人雷军进一步将 2026 年全年交付目标上调至 55 万辆。
#欢迎关注爱范儿官方微信公众号：爱范儿（微信号：ifanr），更多精彩内容第一时间为您奉上。
