我通过电话进行了编码面试，并被问到这个问题：
给定一个字符串（例如）：
“aksdbaalaskdhfbblajdfhacccc aoudgalsaa bblisdfhcccc”
和表达式（例如）：
“A + B + C - ”
其中：
+：表示在重复2次之前的字符
- ：表示在重复4次之前的字符
查找给定表达式出现在字符串中的次数，其中操作数不连续且连续地发生。
上述表达式出现4次：
1) aksdbaalaskdhfbblajdfhacccc aoudgalsaa bblisdfhcccc
^^ ^^ ^^^^
aa bb cccc
2) aksdbaalaskdhfbblajdfhacccc aoudgalsaa bblisdfhcccc
^^ ^^ ^^^^
aa bb cccc
3) aksdbaalaskdhfbblajdfhacccc aoudgalsaa bblisdfhcccc
^^ ^^ ^^^^
aa bb cccc
4) aksdbaalaskdhfbblajdfhacccc aoudgalsaa bblisdfhcccc
^^ ^^ ^^^^
aa bb cccc
我不知道该怎么做。我开始做一个带有大量索引标记的迭代蛮力方法，但意识到在中途编码会有多么混乱和困难：
import java.util.*;
public class Main {
public static int count(String expression, String input) {
int count = 0;
ArrayList<char[]> list = new ArrayList<char[]>();
// Create an ArrayList of chars to iterate through the expression and match to string
for(int i = 1; i<expression.length(); i=i+2) {
StringBuilder exp = new StringBuilder();
char curr = expression.charAt(i-1);
if(expression.charAt(i) == '+') {
exp.append(curr).append(curr);
list.add(exp.toString().toCharArray());
}
else { // character is '-'
exp.append(curr).append(curr).append(curr).append(curr);
list.add(exp.toString().toCharArray());
}
}
char[] inputArray = input.toCharArray();
int i = 0; // outside pointer
int j = 0; // inside pointer
while(i <= inputArray.length) {
while(j <= inputArray.length) {
for(int k = 0; k< list.size(); k++) {
/* loop through
* all possible combinations in array list
* with multiple loops
*/
}
j++;
}
i++;
j=i;
}
return count;
}
public static void main(String[] args) {
String expression = "a+b+c-";
String input = "aaksdbaalaskdhfbblajdfhacccc aoudgalsaa bblisdfhcccc";
System.out.println("The expression occurs: "+count(expression, input)+" times");
}
}
在花了很多时间迭代地进行迭代之后，他提到了递归，我仍然看不到一种明确的递归方式，我无法解决问题。我现在试图在面试后解决它，但我仍然不确定如何解决这个问题。我该如何解决这个问题？解决方案明显吗？我认为对于编码电话采访来说这是一个非常难的问题。
答案 0 :(得分：4)
非递归算法，需要 O（m）空间并在 O（n * m）中运行，其中m是查询中的标记数：
@Test
public void subequences() {
String input = "aabbccaacccccbbd";
String query = "a+b+";
// here to store tokens of a query: e.g. {a, +}, {b, +}
char[][] q = new char[query.length() / 2][];
// here to store counts of subsequences ending by j-th token found so far
int[] c = new int[query.length() / 2]; // main
int[] cc = new int[query.length() / 2]; // aux
// tokenize
for (int i = 0; i < query.length(); i += 2)
q[i / 2] = new char[] {query.charAt(i), query.charAt(i + 1)};
// init
char[] sub2 = {0, 0}; // accumulator capturing last 2 chars
char[] sub4 = {0, 0, 0, 0}; // accumulator capturing last 4 chars
// main loop
for (int i = 0; i < input.length(); i++) {
shift(sub2, input.charAt(i));
shift(sub4, input.charAt(i));
boolean all2 = sub2[1] != 0 && sub2[0] == sub2[1]; // true if all sub2 chars are same
boolean all4 = sub4[3] != 0 && sub4[0] == sub4[1] // true if all sub4 chars are same
&& sub4[0] == sub4[2] && sub4[0] == sub4[3];
// iterate tokens
for (int j = 0; j < c.length; j++) {
if (all2 && q[j][1] == '+' && q[j][0] == sub2[0]) // found match for "+" token
cc[j] = j == 0 // filling up aux array
? c[j] + 1 // first token, increment counter by 1
: c[j] + c[j - 1]; // add value of preceding token counter
if (all4 && q[j][1] == '-' && q[j][0] == sub4[0]) // found match for "-" token
cc[j] = j == 0
? c[j] + 1
: c[j] + c[j - 1];
}
if (all2) sub2[1] = 0; // clear, to make "aa" occur in "aaaa" 2, not 3 times
if (all4) sub4[3] = 0;
copy(cc, c); // copy aux array to main
}
}
System.out.println(c[c.length - 1]);
}
// shifts array 1 char left and puts c at the end
void shift(char[] cc, char c) {
for (int i = 1; i < cc.length; i++)
cc[i - 1] = cc[i];
cc[cc.length - 1] = c;
}
// copies array contents
void copy(int[] from, int[] to) {
for (int i = 0; i < from.length; i++)
to[i] = from[i];
}
主要思想是逐个从输入中捕获字符，将它们保存在2和4字符累加器中，并检查它们是否与查询的某些标记匹配，记住我们获得了多少匹配到目前为止以这些令牌结尾的查询。
查询（a+b+c-）被拆分为令牌（a+，b+，c-）。然后我们收集累加器中的字符并检查它们是否与某些令牌匹配。如果我们找到第一个令牌的匹配，我们将其计数器增加1.如果我们找到另一个第j个令牌的匹配，我们可以创建与由令牌组成的子查询匹配的更多子序列[0] ... j] ，因为许多现在存在用于由标记[0 ... j-1] 组成的子查询，因为这个匹配可以附加到它们中。 / p>
例如，我们有：
a+ : 3 (3 matches for a+)
b+ : 2 (2 matches for a+b+)
c- : 1 (1 match for a+b+c-)
cccc到来时然后，c-计数器应增加b+计数器值，因为到目前为止，我们有2 a+b+个子序列，cccc可以附加到它们。
答案 1 :(得分：3)
让我们调用字符串n的长度和查询表达式的长度（根据＆＃34;单位＆＃34;的数量，如a+或{{1} }）m。
不清楚你的意思是什么？＃34;不断地＆＃34;并且＆＃34;非连续＆＃34;但是如果＆＃34;连续＆＃34;意味着查询字符串单元之间不存在任何差距，那么您可以使用KMP algorithm在O（m + n）时间内查找所有实例。
我们可以解决＆＃34;非连续＆＃34;使用dynamic programming在O（nm）时间和空间中的版本。基本上，我们想要计算的是一个函数：
b-因此，对于您的示例，f（2,41）= 2，因为在示例字符串的前41个字符中有2个单独出现的子模式f(i, j) = the number of occurrences of the subquery consisting of the first i units
of the query expression, in the first j characters of the string.
。
最后的答案将是f（n，m）。
我们可以按如下方式递归计算：
a+b+其中f(0, j) = 0
f(i, 0) = 0
f(i > 0, j > 0) = f(i, j-1) + isMatch(i, j) * f(i-1, j-len(i))
是表达式中第i个单位的长度（总是2或4），len(i)是一个函数，如果表达式中的第i个单位与文本匹配，则返回1在位置j结束，否则为0。例如，您的示例中isMatch(i, j) = 1，因为s [14..15] = isMatch(15, 2)。此函数只需要运行一段时间，因为它永远不需要检查超过4个字符。
上面的递归已经按原样运行，但我们可以确保只解决每个子问题一次，从而节省时间。因为函数f（）仅依赖于它的2个参数i和j，它们分别在0和m之间，以及0和n之间，我们可以计算所有n * m个可能的答案并将它们存储在表中。
[编辑：正如Sasha Salauyou指出的那样，空间要求实际上可以减少到O（m）。我们永远不需要访问f（i，k）的值，其中k
答案 2 :(得分：0)
递归可能是以下（伪代码）：
int search(String s, String expression) {
if expression consists of only one token t /* e. g. "a+" */ {
search for t in s
return number of occurrences
} else {
int result = 0
divide expression into first token t and rest expression
// e. g. "a+a+b-" -> t = "a+", rest = "a+b-"
search for t in s
for each occurrence {
s1 = substring of s from the position of occurrence to the end
result += search(s1, rest) // search for rest of expression in rest of string
}
return result
}
}
将此应用于整个字符串，您将获得非连续出现的次数。要连续出现，你根本不需要递归 - 只需将表达式转换为字符串并按迭代搜索。
答案 3 :(得分：0)
如何预处理aksdbaalaskdhfbblajdfhacccc aoudgalsaa bblisdfhcccc？
这变为a1k1s1d1b1a2l1a1s1k1d1h1f1b2l1a1j1d1f1h1a1c4a1o1u1d1g1a1l1s1a2b2l1i1s1d1f1h1c4
现在找到a2，b2，c4的出现次数。
答案 4 :(得分：0)
尝试下面的代码，但现在它首先只提供基于深度的第一个可能的匹配。
需要更改为完成所有可能的组合，而不仅仅是第一次
{ max. 50 objects can be associated }
答案 5 :(得分：0)
如果您首先使用简单的解析器/编译器转换搜索字符串，以便a+变为aa等，那么您可以简单地使用此字符串并针对您的干草堆运行正则表达式匹配。 （对不起，我没有Java编码器，因此无法提供任何实际代码，但这并不困难）