问题描述
给定两个字符串s1和s2,问s2最少删除多少字符可以成为s1的子串?比如 s1 = "abcde",s2 = "axbc"返回1。s2删掉'x'就是s1的子串了。
思路
思路一:
求str2所有的子序列,然后按照长度排序,长度大的排在前面,然后考察那个子序列字符串和str1的某个子串相同(KMP算法)。
这种算法要求样本数据中str2的长度很小。如果str1的长度远远小于str2的长度这种思想就不合适了。这是因为:若str1长度为N,str2的长度为M,str2的子序列的个数为2^M个,KMP算法的时间复杂度为O(n),综上算法整体的时间复杂度为:O(2^M*N)。若2^M*N的数值小于10^8(10^8:在用java解题时一般要求在2-3秒内,这个时间段的数值大小一般在10^8-10^9之间)即可以使用该思想解题。
思路二:
生成所有的str1的子串,然后考察每个子串和str2的编辑距离(假设编辑距离只有删除动作且删除每一个字符的代价为1。编辑距离可以参考:返回将str1编辑成str2的最小代价_朂後 哋箹萣的博客-CSDN博客)。
每一个str1的子串都会与str2生成一个dp的二维数组。dp[i][j]行用str2的长度表示,列用str1的子串的长度表示。dp[i][j]的含义是:str2[0...i]仅通过删除行为变为str1的子串的最小代价。
dp[0][0]的值是判断str2的第一个字符是否与str1的最小子字符串(只有一个字符)一样,一样则是0,不一样则保存系统最大值。
dp[0][j]表示str2只有第一个字符,str1的子串不是最小子字符串,str2不可能通过删除字符的形式转化为str1,所以这一行全部存入系统最大值。
dp[i][0]表示str1最小子字符串,str2不止一个字符。这种情况是有可能实现的,只需要查看str2的全部字符中是否存在str1最小子字符串(只有一个字符)即可。
对于任意的dp[i][j]有两种可能性(s1sub[]是str1[]的子串):
- str2[0..i]变的过程中,不保留最后一个字符(str2[i)。那么就是通过str2[0...i-1]变成s1sub[0...j]之后,再删除str2[i]即可:dp[i][j] = dp[i - 1][j] + 1。
- str2[0...i]变得过程中,想保留最后一个字符(str2[i]),然后变成s1sub[0...j],这就要求str2[i] == s1sub[j]才有可能,然后str2[0...i-1]变成s1sub[0...j-1]即可,也就是dp[i][j]=dp[i - 1][j - 1]。
若str1长度为N,str2长度为M。str1生成子串时间复杂度为:O(N^2),遍历生成的dp二维表时间复杂度为O(N*M),综上算法的时间复杂度为:O(N^3*M)。
如果str1的长度比较小,str2的长度比较大这个方法也适用。
思路三:
在思路二的基础上,进行改进。思想二每一个str1的子串都会与str2生成一个dp的二维数组,我们会发现str1的子串只要是开头字符相同的字符串由长到短,只需要dp二维数组右边加一行即可,上面的二维数组的数据是不改变的。根据这一思想,算法的时间复杂度由原来的的O(N^3*M)转变为了O(N^2*M)。
在实际的题目中我们可以根据题目中给定的str1和str2的长度计算2^M*N和N^2*M,进而选择合适的算法解题。
代码
思想一代码:
public static int minCost1(String s1, String s2) {
List<String> s2Subs = new ArrayList<>();
process(s2.toCharArray(), 0, "", s2Subs);
s2Subs.sort(new LenComp());
for (String str : s2Subs) {
if (s1.indexOf(str) != -1) {
return s2.length() - str.length();
}
}
return s2.length();
}
public static void process(char[] str2, int index, String path, List<String> list) {
if (index == str2.length) {
list.add(path);
return;
}
process(str2, index + 1, path, list);
process(str2, index + 1, path + str2[index], list);
}
public static class LenComp implements Comparator<String> {
@Override
public int compare(String o1, String o2) {
return o2.length() - o1.length();
}
}
思想二代码:
public static int minCost2(String s1, String s2) {
if (s1.length() == 0 || s2.length() == 0) {
return s2.length();
}
int ans = Integer.MAX_VALUE;
char[] str2 = s2.toCharArray();
for (int start = 0; start < s1.length(); start++) {
for (int end = start+1; end <= s1.length(); end++) {
char[] s1sub = s1.substring(start, end).toCharArray();
ans = Math.min(ans, distance(str2, s1sub));
}
}
return ans;
}
public static int distance(char[] str2, char[] s1sub) {
int row = str2.length;
int col = s1sub.length;
int[][] dp = new int[row][col];
dp[0][0] = str2[0] == s1sub[0] ? 0 : Integer.MAX_VALUE;
for (int j = 1; j < col; j++) {
dp[0][j] = Integer.MAX_VALUE;
}
for (int i = 1; i < row; i++) {
dp[i][0] = (dp[i - 1][0] != Integer.MAX_VALUE || str2[i] == s1sub[0]) ? i : Integer.MAX_VALUE;
}
for (int i = 1; i < row; i++) {
for (int j = 1; j < col; j++) {
dp[i][j] = Integer.MAX_VALUE;
if (dp[i - 1][j] != Integer.MAX_VALUE) {
dp[i][j] = dp[i - 1][j] + 1;
}
if (str2[i] == s1sub[j] && dp[i - 1][j - 1] != Integer.MAX_VALUE) {
dp[i][j] = Math.min(dp[i][j], dp[i - 1][j - 1]);
}
}
}
return dp[row - 1][col - 1];
}
思想三代码:
public static int minCost3(String s1, String s2) {
if (s1.length() == 0 || s2.length() == 0) {
return s2.length();
}
char[] str2 = s2.toCharArray();
char[] str1 = s1.toCharArray();
int M = str2.length;
int N = str1.length;
int[][] dp = new int[M][N];
int ans = M;
for (int start = 0; start < N; start++) {
dp[0][start] = str2[0] == str1[start] ? 0 : M;
for (int row = 1; row < M; row++) {
dp[row][start] = (str2[row] == str1[start] || dp[row - 1][start] != M) ? row : M;
}
ans = Math.min(ans, dp[M - 1][start]);
for (int end = start + 1; end < N && end - start < M; end++) {
int first = end - start;
dp[first][end] = (str2[first] == str1[end] && dp[first - 1][end - 1] != M) ? 0 : M;
for (int row = first + 1; row < M; row++) {
dp[row][end] = M;
if (dp[row - 1][end] != M) {
dp[row][end] = dp[row - 1][end] + 1;
}
if (dp[row - 1][end - 1] != M && str2[row] == str1[end]) {
dp[row][end] = Math.min(dp[row][end], dp[row - 1][end - 1]);
}
}
ans = Math.min(ans, dp[M - 1][end]);
}
}
return ans;
}
public static String generateRandomString(int l, int v) {
int len = (int) (Math.random() * l);
char[] str = new char[len];
for (int i = 0; i < len; i++) {
str[i] = (char) ('a' + (int) (Math.random() * v));
}
return String.valueOf(str);
}
public static void main(String[] args) {
int str1Len = 20;
int str2Len = 10;
int v = 5;
int testTime = 100;
boolean pass = true;
System.out.println("test begin");
for (int i = 0; i < 1; i++) {
String str1 = generateRandomString(str1Len, v);
String str2 = generateRandomString(str2Len, v);
int ans1 = minCost1(str1, str2);
int ans2 = minCost2(str1, str2);
int ans3 = minCost3(str1, str2);
if ( ans1 != ans3 || ans2 != ans3) {
pass = false;
System.out.println(str1);
System.out.println(str2);
System.out.println(ans1);
System.out.println(ans2);
System.out.println(ans3);
break;
}
}
System.out.println("test pass : " + pass);
}