力扣刷题之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" 。

题干分析 

题干理解

       这道题要求在字符串text中插入一个字符（该字符必须是pattern[0]或pattern[1]），使得在插入后，text中子序列等于pattern的个数最大化。需要返回这个最大可能的子序列数量。

问题转化

       由于只能插入一个字符，而且只能是pattern[0]或pattern[1]，我们的木表示找到插入的位置和字符，使得插入后text中的pattern子序列数量最大。

算法步骤

1.特殊情况处理：pattern[0] == pattern[1]

• 统计text中'a'的数量：
• 计算插入后的总子序列数量

2.一般情况处理：pattern[0] ！= pattern[1]

      当pattern的两个字符不相同，例如“ab”，我们需要考虑插入pattern[0]或pattern[1]对总序列数量的影响。

统计text中pattern[0]和pattern[1]的数量，以及当前的子序列数量：

//初始化计数器
ll count_a = 0;//统计pattern[0]的数量
ll count_b = 0;//统计pattern[1]的数量
ll total_subseq = 0;//当前的子序列数量

//遍历text
for (int i = 0; i < len; i++) {
    if (text[i] == pattern[0]) {
        count_a++;
    } else if (text[i] == pattern[1]) {
        total_subseq += count_a; // 每当遇到 pattern[1]，累加当前的 count_a
        count_b++;
    }
}

代码解释

count_a：在当前的位置之前出现的pattern[0]的数量。

        当遇到pattern[1]是，之前的每一个pattern[0]都可以和当前的pattern[1]组成一个pattern子序列，因此total_subseq += count_a。

尝试两种插入方式：

方案一：插入pattern[0]

• 插入一个pattern[0]，会使所有的pattern[1]都有一个新的pattern[0]可以组合，因此总的子序列数量增加count_b。

方案二：插入pattern[1]

• 插入一个pattern[1]，会使所有的pattern[0]都有一个新的pattern[1]可以组合，因此总的子序列数量增加count_a。

选择最大值：

• 返回result1和result2中的较大值，即为插入后可能得到的最大子序列数量。

 

long long maximumSubsequenceCount(char* text, char* pattern){
   typedef lng long ll;
   ll count_q = 0;//用于统计pattern[0]在text中出现的次数
   ll total_subseq = 0;//用于累积当前text中的pattern子序列数量
   int len = strlen(text);//用于获取字符串text的长度
   //接下来我们将分为两种情况来讨论
   //情况一：如果pattern的两个字符相同，例如“aa”
   if(pattern[0] == pattern[1]){
      //遍历整个text字符串
      for(int i = 0; i < len; i++){
         //如果当前字符等于pattern[0]
         if(text[i] == pattern[0]){
             count_a++; // 计数器加一，统计 pattern[0] 的总出现次数
         }
      }
      ll n = count_a + 1; // 考虑插入一个 pattern[0]，总的 pattern[0] 数量增加 1
      // 计算插入后能够形成的 pattern 子序列总数
      // 因为 pattern[0] == pattern[1]，所以子序列为两个相同字符的组合
      // 使用组合数公式：C(n, 2) = n * (n - 1) / 2
      return n * (n - 1) / 2;
   }
   // 情况二：如果 pattern 的两个字符不相同，例如 "ab"
   ll count_b = 0; // 用于统计 pattern[1]（模式的第二个字符）在 text 中出现的次数

   // 遍历整个 text 字符串
   for (int i = 0; i < len; i++) {
        // 如果当前字符等于 pattern[0]
        if (text[i] == pattern[0]) {
            count_a++; // 计数器加一，统计 pattern[0] 的出现次数
        }
        // 如果当前字符等于 pattern[1]
        else if (text[i] == pattern[1]) {
            // 每当遇到一个 pattern[1]，就可以与之前所有的 pattern[0] 组成新的子序列
            // 因此，将当前的 count_a（pattern[0] 的数量）累加到 total_subseq
            total_subseq += count_a;
            count_b++; // 计数器加一，统计 pattern[1] 的出现次数
        }
        // 如果当前字符既不是 pattern[0] 也不是 pattern[1]，则不做处理
    }

    // 方案一：尝试插入一个 pattern[0]
    // 插入后，所有的 pattern[1] 都可以与新的 pattern[0] 组成新的子序列
    // 增加的子序列数量等于 count_b（pattern[1] 的总数量）
    ll result1 = total_subseq + count_b;

    // 方案二：尝试插入一个 pattern[1]
    // 插入后，所有的 pattern[0] 都可以与新的 pattern[1] 组成新的子序列
    // 增加的子序列数量等于 count_a（pattern[0] 的总数量）
    ll result2 = total_subseq + count_a;

    // 比较两种方案，返回能够形成最多子序列的结果
    return result1 > result2 ? result1 : result2;
}