---
tags: [贪心算法, 双指针, 字符串, 哈希表, LeetCode]
create time: 2026-05-16 14:30
---

# 80. 划分字母区间

## 题面

给你一个字符串 `s` 。你要把这个字符串划分为尽可能多的片段，满足：**同一字母最多出现在一个片段中**。

返回一个表示每个字符串片段的长度的列表。

**示例 1：**

```
输入：s = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：划分结果为 "ababcbaca"、"defegde"、"hijhklij"。每个字母最多出现在一个片段中。
```

**示例 2：**

```
输入：s = "eccbbbbdec"
输出：[10]
```

> [!info] 核心约束
> - 划分结果按顺序连接后必须等于原字符串（不能重排）
> - 同一字母的所有出现必须落在同一个片段内
> - 目标是使片段数量最大化（等价于每个片段尽量短）

---

## 思路

### 关键问题思考

先问自己一个问题：如果字母 `'a'` 在位置 0 和位置 7 都出现了，那第一个片段至少要覆盖到位置 7，对吗？

> [!tip] 核心观察
> **如果字符 c 的最后出现位置是 last[c]，那么包含该字符的任意片段的右边界至少是 last[c]。**

但这个条件还不够——当第一个片段被迫延伸到位置 7 时，位置 3~7 之间出现的**其他字符**也可能有自己的最后出现位置比 7 更远。所以片段的右边界需要被进一步"推远"。

这引出了贪心策略的核心：**我们不知道第一个片段在哪里结束，但我们可以维护一个"最远能达到的位置"**。

### 解题步骤

| 步骤 | 操作 | 目的 |
|------|------|------|
| **第一步** | 遍历字符串，记录每个字符最后一次出现的位置 | 知道每个字符的"活动范围"右端点 |
| **第二步** | 再次遍历字符串，维护当前片段的起始位置 start 和最远右边界 far | 逐步推进，找到分割点 |
| **第三步** | 对于当前位置 i 的字符 s[i]，将 far 更新为 max(far, last[s[i]]) | 扩展当前片段的覆盖范围 |
| **第四步** | 当 i == far 时，说明当前位置就是当前片段的终点 | 此时可以安全切分 |

### 流程图

```mermaid
flowchart TD
    A[开始] --> B[第一步: 统计每个字符的最后出现位置 last]
    B --> C[初始化 start = 0, far = 0]
    C --> D{遍历字符串 i = 0 → n-1}
    D --> E["far = max(far, last[s[i]])"]
    E --> F{i == far ?}
    F -- 是 --> G[记录片段长度 far - start + 1]
    G --> H[start = far + 1]
    H --> I{i == n-1 ?}
    F -- 否 --> I
    I -- 否 --> D
    I -- 是 --> J[返回结果数组]
```

### 图解示例

以 `s = "ababcbacadefegdehijhklij"` 为例：

```
last 映射: a→8  b→5  c→7  d→14  e→15  f→11  g→13
            h→19  i→22  j→23  k→20  l→21

位置索引:   0 1 2 3 4 5 6 7 8 | 9 1011121314 | 15 16 17 18 19 20 21 22 23
          ┌─┬─┬─┬─┬─┬─┬─┬─┬─┤ ├──┼──┼──┼──┼──┼─┤  ├──┼──┼──┼──┼──┼──┼──┼──┤
字符串:    a b a b c b a c a | d  e  f  e  g  d | e  h  i  j  h  k  l  i  j

片段划分: │     片段1(长9)     │   片段2(长7)  │   片段3(长8)   │
```

**模拟推进过程：**

```
i=0, s[0]='a', far = max(0, last['a']=8) = 8
i=1, s[1]='b', far = max(8, last['b']=5) = 8
i=2, s[2]='a', far = max(8, 8) = 8
i=3, s[3]='b', far = max(8, 5) = 8
i=4, s[4]='c', far = max(8, last['c']=7) = 8
i=5, s[5]='b', far = max(8, 5) = 8
i=6, s[6]='a', far = max(8, 8) = 8
i=7, s[7]='c', far = max(8, 7) = 8
i=8, s[8]='a', far = max(8, 8) = 8  ← i==far，切割！记录 9

i=9, s[9]='d', far = max(9, last['d']=14) = 14
i=10,s[10]='e', far = max(14, last['e']=15) = 15
i=11,s[11]='f', far = max(15, last['f']=11) = 15
i=12,s[12]='e', far = max(15, 15) = 15
i=13,s[13]='g', far = max(15, last['g']=13) = 15
i=14,s[14]='d', far = max(15, 14) = 15
i=15,s[15]='e', far = max(15, 15) = 15  ← i==far，切割！记录 7

i=16...最终 i==far=23，切割！记录 8
```

### 正确性为什么成立？

> [!question] 为什么当 i == far 时可以安全切割？
> 
> **回答思路**：考虑反证法。假设我们在某个位置切割后，后面还有一个片段包含了与前面片段相同的字符 —— 但我们在推进过程中已经把所有已访问字符的 last 值都纳入了 far 的计算，far 就是所有已访问字符的最后出现位置的**最大值**。所以 far 之后的不可能出现前面的任何字符。因此切割是安全的。

### 复杂度分析

| 指标 | 复杂度 | 说明 |
|------|--------|------|
| **时间** | O(n) | 两次线性扫描，n 为字符串长度 |
| **空间** | O(Σ) | Σ 为字符集大小（小写字母 = 26），视为常数 |

---

## 代码提示

### 伪代码

```
函数 partitionLabels(s):
    // Step 1: 建立 char -> last_position 的映射
    创建数组 last[26], 初始化为 0
    for i from 0 to s.length-1:
        last[s[i] - 'a'] = i

    // Step 2: 贪心划分
    创建空结果数组 ans
    start = 0, far = 0
    for i from 0 to s.length-1:
        far = max(far, last[s[i] - 'a'])
        if i == far:
            ans.append(i - start + 1)
            start = i + 1

    return ans
```

---

## 技巧

> [!abstract] 💡 面试技巧
> 
> 1. **"最后一次出现"模式**：这类"元素必须同组"的问题，第一步通常是找每个元素的最后出现位置。类似的题目还有 `[45.跳跃游戏II](./45-跳跃游戏II.md)`、`[56.合并区间](./56-合并区间.md)`。
> 2. **双指针模板**：start 标记片段起点，far 标记片段终点。当到达 far 时就切一刀。这种模板在区间类问题中非常通用。
> 3. **不要提前切割**：即使觉得当前字符在前面都没出现过，也不能轻易在这里切分——因为中间可能有别的字符把它拉得更远。far 变量就是防止过早切割的关键。

---

## 代码

```go
// PartitionLabels 将字符串划分为尽可能多的片段，同一字母最多出现在一个片段中
// 参数 s: 仅由小写英文字母组成的字符串
// 返回值: 每个片段的长度列表
func partitionLabels(s string) []int {
	// 记录每个字符最后一次出现的位置
	last := [26]int{}
	for i, ch := range s {
		last[ch-'a'] = i
	}

	var ans []int
	start, far := 0, 0
	for i := range s {
		// 扩展当前片段的最远边界
		if p := last[s[i]-'a']; p > far {
			far = p
		}
		// 到达当前片段终点，切割
		if i == far {
			ans = append(ans, i-start+1)
			start = i + 1
		}
	}
	return ans
}
```

> [!example] 简洁版写法（利用 len 预分配）
>
> ```go
> func partitionLabels(s string) []int {
> 	last := [26]int{}
> 	for i, ch := range s {
> 		last[ch-'a'] = i
> 	}
>
> 	var ans []int
> 	start := 0
> 	for i, far := 0, 0; i < len(s); i++ {
> 		if p := last[s[i]-'a']; p > far {
> 			far = p
> 		}
> 		if i == far {
> 			ans = append(ans, i-start+1)
> 			start = i + 1
> 		}
> 	}
> 	return ans
> }
> ```