最长相邻不相等子序列 I

难度: Easy

给你一个下标从 0 开始的字符串数组 words ，和一个下标从 0 开始的 二进制 数组 groups ，两个数组长度都是 n 。

你需要从 words 中选出 最长子序列。如果对于序列中的任何两个连续串，二进制数组 groups 中它们的对应元素不同，则 words 的子序列是不同的。

正式来说，你需要从下标 [0, 1, ..., n - 1] 中选出一个 最长子序列 ，将这个子序列记作长度为 k 的 [i₀, i₁, ..., i_{k - 1}] ，对于所有满足 0 <= j < k - 1 的 j 都有 groups[i_j] != groups[i_{j + 1}] 。

请你返回一个字符串数组，它是下标子序列依次对应 words 数组中的字符串连接形成的字符串数组。如果有多个答案，返回任意一个。

注意：words 中的元素是不同的。

示例 1：

输入：words = ["e","a","b"], groups = [0,0,1]
输出：["e","b"]
解释：一个可行的子序列是 [0,2] ，因为 groups[0] != groups[2] 。
所以一个可行的答案是 [words[0],words[2]] = ["e","b"] 。
另一个可行的子序列是 [1,2] ，因为 groups[1] != groups[2] 。
得到答案为 [words[1],words[2]] = ["a","b"] 。
这也是一个可行的答案。
符合题意的最长子序列的长度为 2 。

示例 2：

输入：words = ["a","b","c","d"], groups = [1,0,1,1]
输出：["a","b","c"]
解释：一个可行的子序列为 [0,1,2] 因为 groups[0] != groups[1] 且 groups[1] != groups[2] 。
所以一个可行的答案是 [words[0],words[1],words[2]] = ["a","b","c"] 。
另一个可行的子序列为 [0,1,3] 因为 groups[0] != groups[1] 且 groups[1] != groups[3] 。
得到答案为 [words[0],words[1],words[3]] = ["a","b","d"] 。
这也是一个可行的答案。
符合题意的最长子序列的长度为 3 。

提示：

1 <= n == words.length == groups.length <= 100
1 <= words[i].length <= 10
groups[i] 是 0 或 1。
words 中的字符串 互不相同 。
words[i] 只包含小写英文字母。

Submission

运行时间: 25 ms

内存: 15.9 MB

class Solution:
    def getLongestSubsequence(self, words: List[str], groups: List[int]) -> List[str]:
        arr = [0]
        for i, x in enumerate(groups):
            if x != groups[arr[-1]]:
                arr.append(i)
        return [words[i] for i in arr]

Explain

该题解的核心思路是遍历groups数组，并构建一个索引列表arr，用于记录符合条件的words的索引。初始时，arr包含第一个元素的索引0，表示至少包含words的第一个元素。之后，遍历groups数组，只要当前元素与arr列表中最后一个记录的索引对应的groups值不同，就将当前索引添加到arr中。这样，arr中存储的索引对应的groups值必然是交替变化的，满足题目要求的连续不相等条件。最终，根据arr中的索引，提取words数组中对应的字符串，形成所求的最长子序列。

时间复杂度: O(n)

空间复杂度: O(n)

class Solution:
    def getLongestSubsequence(self, words: List[str], groups: List[int]) -> List[str]:
        arr = [0]  # 初始化索引列表，从第一个元素开始
        for i, x in enumerate(groups[1:], 1):  # 从第二个元素开始遍历groups
            if x != groups[arr[-1]]:  # 检查当前元素与arr中最后一个索引对应的groups值是否不同
                arr.append(i)  # 不同则将当前索引添加到arr
        return [words[i] for i in arr]  # 根据arr中的索引提取对应的words元素

Explore

从第一个元素的索引0开始是基于这样一个前提：至少要包含一个元素以构建子序列。这个决定在groups非空时是有效的，因为至少有一个元素可以开始构建序列。然而，如果groups数组为空，则这一策略将失效，因为不存在任何元素可以被加入到索引列表arr中。在这种情况下，算法应该首先检查groups是否为空，如果为空，则直接返回一个空的words子序列。

如果groups数组中存在连续的相同值，算法将跳过这些连续相同的值，只在值变化时添加索引到arr中。这意味着arr将不会包含所有索引，而只包含那些对应于groups值变化点的索引。这种处理方式确保了构建的子序列满足相邻不相等的条件，同时尽可能地长。

在函数中使用enumerate来遍历groups数组可以同时获得元素的索引和值，这使得代码更为简洁和直观。使用enumerate避免了需要手动处理索引，如在传统for循环中需要使用range(len(groups))。这种方法提高了代码的可读性和减少了出错的可能性，因为它直接提供了每个元素的索引和对应的值。

题目说明words中的元素是不同的，这简化了算法设计，因为不需要考虑去重或处理相同元素带来的复杂性。如果words中存在相同的元素，该算法依然适用，因为算法主要依赖于groups数组来确定哪些words元素应该被选取。只要groups数组的处理逻辑不变，即使words中有重复元素，也可以正确地根据groups数组构建符合条件的子序列。