给定字符串S 中存在的子序列 T 的最大相邻索引差

给定两个长度分别为n和m的字符串S和T。查找字符串T 作为子序列存在于字符串S 中的索引的最大相邻索引差。

成本定义为子序列 T 的索引之间的差异
对于1 ≤ i < m ，序列的最大成本定义为max(a _i+1 −a _i ) 。
保证在 S中至少有 T 的子序列。

例子：

Input: S = “abbbc”, T = “abc”
Output: 3
Explanation: One of the subsequences is {1, 4, 5} denoting the sequence “abc” same as T, thus the maximum cost is 4 – 1 = 3 .

Input: S = “aaaaa”, T = “aa”
Output: 4
Explanation: One of the subsequences is {1, 5} and the max cost is 5 – 1 = 4 .

编程需要懂一点英语

方法：对于字符串S 的某个子序列，令 a _i表示字符T _i在字符串S 中的位置。对于固定的 i，我们可以找到最大化a _i+1 -a _i的子序列。

请按照以下步骤解决问题：

令left _i和right _i分别是所有有效 a 中 a _i的最小和最大可能值。现在，很容易看出 a _i+1 - a _i的最大可能值等于right _i+1 - left _i 。
要计算left _i ，我们只需要找到left _i-1之后的第一个元素，它等于T _i ，right _i可以通过反向迭代以相同的方式找到。
所以，在找到左右之后，答案是max(right _i+1 −left _i ) ，因为 1 ≤ i < m。

下面是上述方法的实现。

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to find the maximum
// cost of a subsequence
int maxCost(string s, string t, int n, int m)
{
    // mxCost stores the maximum
    // cost of a subsequence
    int mxCost = 0;
 
    // left[i] and right[i] store
    // the minimum and maximum
    // value of ai among all
    // valid a's respectively
    int left[m], right[m];
 
    int j = 0;
    for (int i = 0; i < n; i++) {
        if (j >= m)
            break;
 
        if (s[i] == t[j]) {
            left[j] = i;
            j++;
        }
    }
 
    j = m - 1;
    for (int i = n - 1; i >= 0; i--) {
        if (j < 0)
            break;
 
        if (s[i] == t[j]) {
            right[j] = i;
            j--;
        }
    }
 
    for (int i = 0; i < m - 1; i++) {
        mxCost = max(mxCost,
                     right[i + 1] - left[i]);
    }
 
    return mxCost;
}
 
// Driver function
int main()
{
    string S = "abbbc", T = "abc";
    int n = S.length(), m = T.length();
 
    // Function Call
    cout << maxCost(S, T, n, m);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
  // Function to find the maximum
  // cost of a subsequence
  static int maxCost(String s, String t, int n, int m)
  {
    // mxCost stores the maximum
    // cost of a subsequence
    int mxCost = 0;
 
    // left[i] and right[i] store
    // the minimum and maximum
    // value of ai among all
    // valid a's respectively
    int []left = new int[m];
    int []right = new int[m];
 
    int j = 0;
    for (int i = 0; i < n; i++) {
      if (j >= m)
        break;
 
      if (s.charAt(i) == t.charAt(j)) {
        left[j] = i;
        j++;
      }
    }
 
    j = m - 1;
    for (int i = n - 1; i >= 0; i--) {
      if (j < 0)
        break;
 
      if (s.charAt(i) == t.charAt(j)) {
        right[j] = i;
        j--;
      }
    }
 
    for (int i = 0; i < m - 1; i++) {
      mxCost = Math.max(mxCost,
                        right[i + 1] - left[i]);
    }
 
    return mxCost;
  }
 
  // Driver function
  public static void main(String[] args)
  {
    String S = "abbbc", T = "abc";
    int n = S.length(), m = T.length();
 
    // Function Call
    System.out.print(maxCost(S, T, n, m));
  }
}
 
// This code is contributed by 29AjayKumar

Python

# Python program for the above approach
 
# Function to find the maximum
# cost of a subsequence
def maxCost(s, t, n, m):
     
    # mxCost stores the maximum
    # cost of a subsequence
    mxCost = 0
 
    # left[i] and right[i] store
    # the minimum and maximum
    # value of ai among all
    # valid a's respectively
    left = []
    right = []
 
    j = 0
    for i in range(0, n):
        if (j >= m):
            break
 
        if (s[i] == t[j]):
            left.append(i)
            j += 1
 
    j = m - 1
    for i in reversed(range(n)):
        if (j < 0):
            break
 
        if (s[i] == t[j]):
            right.append(i)
            j -= 1
 
    for i in range(0, m - 1):
        mxCost = max(mxCost, right[i + 1] - left[i])
 
    return mxCost
 
# Driver function
S = "abbbc"
T = "abc"
n = len(S)
m = len(T)
 
print(maxCost(S, T, n, m))
 
# This code is contributed by Samim Hossain Mondal.

C#

// C# program for the above approach
using System;
class GFG{
 
  // Function to find the maximum
  // cost of a subsequence
  static int maxCost(String s, String t, int n, int m)
  {
 
    // mxCost stores the maximum
    // cost of a subsequence
    int mxCost = 0;
 
    // left[i] and right[i] store
    // the minimum and maximum
    // value of ai among all
    // valid a's respectively
    int []left = new int[m];
    int []right = new int[m];
 
    int j = 0;
    for (int i = 0; i < n; i++) {
      if (j >= m)
        break;
 
      if (s[i] == t[j]) {
        left[j] = i;
        j++;
      }
    }
 
    j = m - 1;
    for (int i = n - 1; i >= 0; i--) {
      if (j < 0)
        break;
 
      if (s[i] == t[j]) {
        right[j] = i;
        j--;
      }
    }
 
    for (int i = 0; i < m - 1; i++) {
      mxCost = Math.Max(mxCost,  right[i + 1] - left[i]);
    }
 
    return mxCost;
  }
 
  // Driver function
  public static void Main()
  {
    String S = "abbbc", T = "abc";
    int n = S.Length, m = T.Length;
 
    // Function Call
    Console.Write(maxCost(S, T, n, m));
  }
}
 
// This code is contributed by gfgking

Javascript

输出

时间复杂度： O(n + m)
辅助空间： O(n)