2207. 字符串中最多数目的子序列(leetcode每日一题）

2207. 字符串中最多数目的子序列

给你一个下标从 0 开始的字符串 text 和另一个下标从 0 开始且长度为 2 的字符串 pattern ，两者都只包含小写英文字母。

你可以在 text 中任意位置插入 一个 字符，这个插入的字符必须是 pattern[0] 或者 pattern[1] 。注意，这个字符可以插入在 text 开头或者结尾的位置。

请你返回插入一个字符后，text 中最多包含多少个等于 pattern 的 子序列 。

子序列 指的是将一个字符串删除若干个字符后（也可以不删除），剩余字符保持原本顺序得到的字符串。

示例 1：

输入：text = "abdcdbc", pattern = "ac"
输出：4
解释：
如果我们在 text[1] 和 text[2] 之间添加 pattern[0] = 'a' ，那么我们得到 "abadcdbc" 。那么 "ac" 作为子序列出现 4 次。
其他得到 4 个 "ac" 子序列的方案还有 "aabdcdbc" 和 "abdacdbc" 。
但是，"abdcadbc" ，"abdccdbc" 和 "abdcdbcc" 这些字符串虽然是可行的插入方案，但是只出现了 3 次 "ac" 子序列，所以不是最优解。
可以证明插入一个字符后，无法得到超过 4 个 "ac" 子序列。

示例 2：

输入：text = "aabb", pattern = "ab"
输出：6
解释：
可以得到 6 个 "ab" 子序列的部分方案为 "aaabb" ，"aaabb" 和 "aabbb" 。

提示：

• 1 <= text.length <= 105
• pattern.length == 2
• text 和 pattern 都只包含小写英文字母。

解：

读题：一个字符串里面任意位置插入一个指定字符。求最多子序列个数。

        子序列还个数。这妥妥的地狱难度啊！一个中等的题不至于这么搞我吧！摔⌨️。
        仔细看了一下题目，哎！这个子序列pattern只有两个元素。瞬间把扔走的键盘又捡回来了，我感觉我还能抢救一下。

        好吧！国际惯例模拟找规律。

看示例1：text = "abdcdbc", pattern = "ac"
首先肯定是清洗数据， 非a/c数据全部清除，得到结果"acc"
现有的组合有多少种？0/1和0/2两种。

现在我们想想我们要插入的字符是谁？我也不知道啊!只能一个一个的来实验.

先试试插入第一个字符a。位置插入哪儿？队首/队中/队尾？
因为要求最多子序列个数，所以插入的a要和更多的c结合。
插入队尾行不行?一个都结合不了显然不行.插入队中可能能全部结合也可能不全部结合。插入对首最保险了。
a插入对首能让子序列最多，比原来的多了多少个呢？有多少个c就多了多少个。

现在我们来试试插入第二个字符c。位置插入哪儿？队首/队中/队尾？
因为要求最多子序列个数，所以插入的c要和更多的a结合。
插入队首行不行?一个都结合不了显然不行.插入队中可能能全部结合也可能不全部结合。插入队尾最保险了。
c插入队尾能让子序列最多，比原来的多了多少个呢？有多少个a就多了多少个。

阶段性结论来了。

若果想要获得最多子序列，插入新的字符会导致原始序列多出另外一种字符的个数。
result=原始序列个数+ max(字符text种pattern[0]个数，字符text种pattern[1]个数)

上面的例题我们一眼就看出了原始序列的个数=2.

复杂一点的怎么计算呢？示例：acacacacacaaccaaccaac
第一个a可以和多少个c结合呢？ 和全部的c
第二个a呢？全部c-1（因为刚才遍历过去了一个c）

写出代码如下：

# pattern[0] 元素个数
red_count = text.count(pattern[0])
# pattern[1] 元素个数
blue_count = text.count(pattern[1])
# 组合个数。
result = 0
for v in text:
    # 匹配pattern[0]元素，记录左侧元素个数
    if v == pattern[0]:
        result += blue_count
    # 匹配pattern[1]元素，左侧元素个数-1
    if v == pattern[1]:
        blue_count -= 1
print(result)

        这个代码怎么这么别扭呢？先求个数，再用个数-1.感觉有点反人类。顺序匹配的逻辑没有毛病。但是看着有点难受。
        这个子序列如果反馈到社会上会是一个什么场景呢？
我们把pattern[0]叫做红队，pattern[1]叫做蓝队。
现在要搞一场红蓝对抗赛。现在已经按照顺序排好了大家的排名，并且红队只能选择和蓝队对抗。问一共可以有多少种对抗组合？

按照刚才顺序匹配的逻辑是怎么一回事呢？
从第一名红队开始进行匹配。匹配个数呢？它身后所有蓝队的数量。
再从第二名红队开始进行匹配，匹配个数呢？它身后的所有蓝队的数量。

但是我们要计算初始的蓝队数量比较消耗时间和性能。怎么办呢？
能用红队匹配蓝队，那么能不能用蓝队匹配红队呢？
开始遍历，遇到红队就个数+1. 遇到蓝队就累加它前面多少个红队。

# pattern[0] 元素个数
red_count = 0
# 结果
result = 0
for v in text:
    # 遇到红队，红队数量+1
    if v == pattern[0]:
        red_count += 1
    # 遇到蓝队，累加当前红队数量。
    if v == pattern[1]:
        result +=red_count

好了把两部分代码组合起来（红队蓝队都是同一个值的时候为特例）。

python代码

def maximumSubsequenceCount1(self, text: str, pattern: str) -> int:
    red_count,blue_count,result = 0,0,0
    for v in text:
        # 遇到红队，红队数量+1
        if v == pattern[0]:
            red_count += 1
        # 遇到蓝队，累加当前红队数量。
        if v == pattern[1]:
            result +=red_count
            blue_count+=1
    return result + (max(red_count, blue_count) if pattern[0] != pattern[1] else 0)