LeetCode-763. 划分字母区间

问题地址

LeetCode每日一题/2020-10-22

LeetCode763. 划分字母区间

问题描述

规则

字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一个字母只会出现在其中的一个片段。返回一个表示每个字符串片段的长度的列表。

示例

• 示例1

输入：S = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca", "defegde", "hijhklij"。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。

提示

• S的长度在[1, 500]之间。
• S只包含小写字母 ‘a’ 到 ‘z’ 。

思路分析

数据操作分析

• 见思路分析

复杂度分析

1. 时间复杂度
2. 空间复杂度

编码实现

官方解法

方法一 贪心算法 + 双指针

思路与算法：

• 由于同一个字母只能出现在同一个片段，显然同一个字母的第一次出现的下标位置和最后一次出现的下标位置必须出现在同一个片段。因此需要遍历字符串，得到每个字母最后一次出现的下标位置。
• 在得到每个字母最后一次出现的下标位置之后，可以使用贪心算法和双指针的方法将字符串划分为尽可能多的片段，具体做法如下。
  • 从左到右遍历字符串，遍历的同时维护当前片段的开始下标 \textit{start} 和结束下标 \textit{end}，初始时 \textit{start}=\textit{end}=0。
  • 对于每个访问到的字母 c，得到当前字母的最后一次出现的下标位置 \textit{end}_c ，则当前片段的结束下标一定不会小于 \textit{end}_c ，因此令 \textit{end}=\max(\textit{end},\textit{end}_c) 。
  • 当访问到下标 \textit{end} 时，当前片段访问结束，当前片段的下标范围是 [\textit{start},\textit{end}]，长度为 \textit{end}-\textit{start}+1，将当前片段的长度添加到返回值，然后令 \textit{start}=\textit{end}+1，继续寻找下一个片段。
  • 重复上述过程，直到遍历完字符串。
    -上述做法使用贪心的思想寻找每个片段可能的最小结束下标，因此可以保证每个片段的长度一定是符合要求的最短长度，如果取更短的片段，则一定会出现同一个字母出现在多个片段中的情况。由于每次取的片段都是符合要求的最短的片段，因此得到的片段数也是最多的。
• 由于每个片段访问结束的标志是访问到下标 \textit{end}，因此对于每个片段，可以保证当前片段中的每个字母都一定在当前片段中，不可能出现在其他片段，可以保证同一个字母只会出现在同一个片段。

复杂度分析：

1. 时间复杂度:O(n)，其中 n 是字符串的长度。需要遍历字符串两次，第一次遍历时记录每个字母最后一次出现的下标位置，第二次遍历时进行字符串的划分。

2. 空间复杂度：O(\Sigma)，其中 \Sigma 是字符串中的字符集大小。这道题中，字符串只包含小写字母，因此 \Sigma=26。

编码实现

class Solution {
    public List<Integer> partitionLabels(String S) {
        int[] last = new int[26];
        int length = S.length();
        for (int i = 0; i < length; i++) {
            last[S.charAt(i) - 'a'] = i;
        }
        List<Integer> partition = new ArrayList<Integer>();
        int start = 0, end = 0;
        for (int i = 0; i < length; i++) {
            end = Math.max(end, last[S.charAt(i) - 'a']);
            if (i == end) {
                partition.add(end - start + 1);
                start = end + 1;
            }
        }
        return partition;
    }
}

精彩评论

跳转地址1：763. 划分字母区间:【记录最远位置与双指针】详解

思路

• 一想到分割字符串就想到了回溯，但本题其实不用那么复杂。
• 可以分为如下两步：
  • 统计每一个字符最后出现的位置
  • 从头遍历字符，如果找到之前字符最大出现位置下标和当前下标相等，则找到了分割点
• 如图：
  

编码实现

• 明白原理之后，代码并不复杂，如下：

class Solution {
public:
    vector<int> partitionLabels(string S) {
        unordered_map<char, int> umap; // key:字符，value：字符出现的最后位置
        for (int i = 0; i < S.size(); i++) { // 统计每一个字符最后出现的位置
            umap[S[i]] = i;
        }
        vector<int> result;
        int left = 0;
        int right = 0;
        for (int i = 0; i < S.size(); i++) {
            right = max(right, umap[S[i]]); // 找到字符出现的最远边界
            if (i == right) {
                result.push_back(right - left + 1);
                left = i + 1;
            }
        }
        return result;
    }
};

跳转地址2：『手画图解』划分字母区间 | 记录最远位置

思路

想切割，要有首尾两个指针，确定了结尾指针，就能确定下一个切割的开始指针。
遍历字符串，如果已扫描部分的所有字符，都只出现在已扫描的范围内，即可做切割。
下图已扫描的绿色字符，对应的最远位置，都不超过 8，在 8 这切一刀，[0:8]的字符都不会出现在别处。

maintain「已扫描的字符能去到的最远位置」，扫到这个位置就切割，切出的字符不会在之后出现。
更新开始指针，准备下一次切割。

• 一些变量
  • maxPos 一个Map，记录每个字母对应的最远位置。
  • start 做切割的开始位置。
  • scannedCharMaxPos 已扫描的字符能去到的最远位置。

编码实现

const partitionLabels = (S) => {
  const maxPos = {};
  for (let i = 0; i < S.length; i++) { // 存放字母与它的最远位置
    maxPos[S[i]] = i;
  }

  const res = [];
  let start = 0;                        // 待切割的起始位置
  let scannedCharMaxPos = 0;            // 已扫描的字符中最远的位置

  for (let i = 0; i < S.length; i++) {
    const curCharMaxPos = maxPos[S[i]]; // 当前扫描的字符的最远位置
    scannedCharMaxPos = Math.max(scannedCharMaxPos, curCharMaxPos); // 更新「已扫描的字符中最远的位置」
    if (i == scannedCharMaxPos) { // 正好扫描到「已扫描的字符的最远位置」，到达切割点
      res.push(i - start + 1);
      start = i + 1;              // 更新，下一个待切割的字符串的起始位置
    }
  }
  return res;
};