blocks|key|3042675|text|def+common_prefix(strings):
++++"""+Find+the+longest+string+that+is+a+prefix+of+all+the+strings.
++++"""
++++if+not+strings:
++++++++return+''
++++prefix+=+strings[0]
++++for+s+in+strings:
++++++++if+len(s)+<+len(prefix):
++++++++++++prefix+=+prefix[:len(s)]
++++++++if+not+prefix:
++++++++++++return+''
++++++++for+i+in+range(len(prefix)):
++++++++++++if+prefix[i]+!=+s[i]:
++++++++++++++++prefix+=+prefix[:i]
++++++++++++++++break
++++return+prefix|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3042676|来自http://bitbucket.org/ned/cog/src/tip/cogapp/whiteutils.py|unstyled|offset|length|3042677|entityMap|0|LINK|mutability|MUTABLE|url|http://bitbucket.org/ned/cog/src/tip/cogapp/whiteutils.py^0|0|2|1L|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@$G|S|H|T|1|U]]|A|$]]|$1|I|3|-4|5|F|7|V|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|P]]]]

<pre><code>def common_prefix(strings):
 """ Find the longest string that is a prefix of all the strings.
 """
 if not strings:
 return ''
 prefix = strings[0]
 for s in strings:
 if len(s) &lt; len(prefix):
 prefix = prefix[:len(s)]
 if not prefix:
 return ''
 for i in range(len(prefix)):
 if prefix[i] != s[i]:
 prefix = prefix[:i]
 break
 return prefix
</code></pre>

From <a href="http://bitbucket.org/ned/cog/src/tip/cogapp/whiteutils.py" rel="nofollow noreferrer">http://bitbucket.org/ned/cog/src/tip/cogapp/whiteutils.py</a>

blocks|key|3042708|text|这些成对的函数将在任意字符串数组中找到最长的公共字符串：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3042709|def+long_substr(data):
++++substr+=+''
++++if+len(data)+>+1+and+len(data[0])+>+0:
++++++++for+i+in+range(len(data[0])):
++++++++++++for+j+in+range(len(data[0])-i%2B1):
++++++++++++++++if+j+>+len(substr)+and+is_substr(data[0][i:i%2Bj],+data):
++++++++++++++++++++substr+=+data[0][i:i%2Bj]
++++return+substr

def+is_substr(find,+data):
++++if+len(data)+<+1+and+len(find)+<+1:
++++++++return+False
++++for+i+in+range(len(data)):
++++++++if+find+not+in+data[i]:
++++++++++++return+False
++++return+True


print+long_substr(['Oh,+hello,+my+friend.',
+++++++++++++++++++'I+prefer+Jelly+Belly+beans.',
+++++++++++++++++++'When+hell+freezes+over!'])|code-block|syntax|javascript|3042710|毫无疑问，算法可以改进，而且我没有太多接触Python的经验，所以也许它在语法上也可以更有效，但它应该可以完成这项工作。|3042711|编辑：内联第二个is_substr函数，正如J.F.Sebastian所演示的那样。用法保持不变。注意:算法不变。|offset|length|style|BOLD|3042712|def+long_substr(data):
++++substr+=+''
++++if+len(data)+>+1+and+len(data[0])+>+0:
++++++++for+i+in+range(len(data[0])):
++++++++++++for+j+in+range(len(data[0])-i%2B1):
++++++++++++++++if+j+>+len(substr)+and+all(data[0][i:i%2Bj]+in+x+for+x+in+data):
++++++++++++++++++++substr+=+data[0][i:i%2Bj]
++++return+substr|3042713|希望这能帮上忙|3042714|杰森。|3042715|entityMap^0|0|0|0|0|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

These paired functions will find the longest common string in any arbitrary array of strings:

<pre><code>def long_substr(data):
 substr = ''
 if len(data) &gt; 1 and len(data[0]) &gt; 0:
 for i in range(len(data[0])):
 for j in range(len(data[0])-i+1):
 if j &gt; len(substr) and is_substr(data[0][i:i+j], data):
 substr = data[0][i:i+j]
 return substr

def is_substr(find, data):
 if len(data) &lt; 1 and len(find) &lt; 1:
 return False
 for i in range(len(data)):
 if find not in data[i]:
 return False
 return True


print long_substr(['Oh, hello, my friend.',
 'I prefer Jelly Belly beans.',
 'When hell freezes over!'])
</code></pre>

No doubt the algorithm could be improved and I've not had a lot of exposure to Python, so maybe it could be more efficient syntactically as well, but it should do the job.

EDIT: in-lined the second is_substr function as demonstrated by J.F. Sebastian. Usage remains the same. Note: no change to algorithm.

<pre><code>def long_substr(data):
 substr = ''
 if len(data) &gt; 1 and len(data[0]) &gt; 0:
 for i in range(len(data[0])):
 for j in range(len(data[0])-i+1):
 if j &gt; len(substr) and all(data[0][i:i+j] in x for x in data):
 substr = data[0][i:i+j]
 return substr
</code></pre>

Hope this helps,

Jason.

blocks|key|306938|text|#+this+does+not+increase+asymptotical+complexity
#+but+can+still+waste+more+time+than+it+saves.+TODO:+profile
def+shortest_of(strings):
++++return+min(strings,+key=len)

def+long_substr(strings):
++++substr+=+""
++++if+not+strings:
++++++++return+substr
++++reference+=+shortest_of(strings)+#strings[0]
++++length+=+len(reference)
++++#find+a+suitable+slice+i:j
++++for+i+in+xrange(length):
++++++++#only+consider+strings+long+at+least+len(substr)+%2B+1
++++++++for+j+in+xrange(i+%2B+len(substr)+%2B+1,+length+%2B+1):
++++++++++++candidate+=+reference[i:j]++#+↓+is+the+slice+recalculated+every+time?
++++++++++++if+all(candidate+in+text+for+text+in+strings):
++++++++++++++++substr+=+candidate
++++return+substr|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|306939|免责声明这对雅克的回答几乎没有什么帮助。然而，希望这篇文章更具可读性，速度更快，而且它不适合在评论中使用，所以我在回复中发布了这篇文章。老实说，我对shortest_of并不满意。|unstyled|offset|length|style|BOLD|CODE|306940|entityMap^0|0|0|4|22|B|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|O|8|@$G|P|H|Q|I|J]|$G|R|H|S|I|K]]|9|@]|A|$]]|$1|L|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|M|$]]

<pre><code># this does not increase asymptotical complexity
# but can still waste more time than it saves. TODO: profile
def shortest_of(strings):
 return min(strings, key=len)

def long_substr(strings):
 substr = ""
 if not strings:
 return substr
 reference = shortest_of(strings) #strings[0]
 length = len(reference)
 #find a suitable slice i:j
 for i in xrange(length):
 #only consider strings long at least len(substr) + 1
 for j in xrange(i + len(substr) + 1, length + 1):
 candidate = reference[i:j] # ↓ is the slice recalculated every time?
 if all(candidate in text for text in strings):
 substr = candidate
 return substr
</code></pre>

Disclaimer This adds very little to jtjacques' answer. However, hopefully, this should be more readable and faster and it didn't fit in a comment, hence why I'm posting this in an answer. I'm not satisfied about <code>shortest_of</code>, to be honest.

blocks|key|3256687|text|您可以使用SuffixTree模块，它是一个基于通用后缀树的ANSI实现的包装器。该模块易于操作……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3256688|看一下：here|offset|length|3256689|entityMap|0|LINK|mutability|MUTABLE|url|http://www.daimi.au.dk/~mailund/suffix_tree.html^0|0|4|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

You could use the SuffixTree module that is a wrapper based on an ANSI C implementation of generalised suffix trees. The module is easy to handle....

Take a look at: <a href="http://www.daimi.au.dk/~mailund/suffix_tree.html" rel="nofollow">here</a>

blocks|key|307896|text|对于is_substr，我更喜欢这样，因为我发现它更具可读性和直观性：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|307897|def+is_substr(find,+data):
++"""
++inputs+a+substring+to+find,+returns+True+only+
++if+found+for+each+data+in+data+list
++"""

++if+len(find)+<+1+or+len(data)+<+1:
++++return+False+#+expected+input+DNE

++is_found+=+True+#+and-ing+to+False+anywhere+in+data+will+return+False
++for+i+in+data:
++++print+"Looking+for+substring+%25s+in+%25s..."+%25+(find,+i)
++++is_found+=+is_found+and+find+in+i
++return+is_found|code-block|syntax|javascript|307898|entityMap^0|2|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I prefer this for <code>is_substr</code>, as I find it a bit more readable and intuitive:

<pre><code>def is_substr(find, data):
 """
 inputs a substring to find, returns True only 
 if found for each data in data list
 """

 if len(find) &lt; 1 or len(data) &lt; 1:
 return False # expected input DNE

 is_found = True # and-ing to False anywhere in data will return False
 for i in data:
 print "Looking for substring %s in %s..." % (find, i)
 is_found = is_found and find in i
 return is_found
</code></pre>

blocks|key|304875|text|如果有人正在寻找一个通用版本，该版本还可以获取任意对象的序列列表：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|304876|def+get_longest_common_subseq(data):
++++substr+=+[]
++++if+len(data)+>+1+and+len(data[0])+>+0:
++++++++for+i+in+range(len(data[0])):
++++++++++++for+j+in+range(len(data[0])-i%2B1):
++++++++++++++++if+j+>+len(substr)+and+is_subseq_of_any(data[0][i:i%2Bj],+data):
++++++++++++++++++++substr+=+data[0][i:i%2Bj]
++++return+substr

def+is_subseq_of_any(find,+data):
++++if+len(data)+<+1+and+len(find)+<+1:
++++++++return+False
++++for+i+in+range(len(data)):
++++++++if+not+is_subseq(find,+data[i]):
++++++++++++return+False
++++return+True

#+Will+also+return+True+if+possible_subseq+==+seq.
def+is_subseq(possible_subseq,+seq):
++++if+len(possible_subseq)+>+len(seq):
++++++++return+False
++++def+get_length_n_slices(n):
++++++++for+i+in+xrange(len(seq)+%2B+1+-+n):
++++++++++++yield+seq[i:i%2Bn]
++++for+slyce+in+get_length_n_slices(len(possible_subseq)):
++++++++if+slyce+==+possible_subseq:
++++++++++++return+True
++++return+False

print+get_longest_common_subseq([[1,+2,+3,+4,+5],+[2,+3,+4,+5,+6]])

print+get_longest_common_subseq(['Oh,+hello,+my+friend.',
+++++++++++++++++++++++++++++++++++++'I+prefer+Jelly+Belly+beans.',
+++++++++++++++++++++++++++++++++++++'When+hell+freezes+over!'])|code-block|syntax|javascript|304877|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If someone is looking for a generalized version that can also take a list of sequences of arbitrary objects:

<pre><code>def get_longest_common_subseq(data):
 substr = []
 if len(data) &gt; 1 and len(data[0]) &gt; 0:
 for i in range(len(data[0])):
 for j in range(len(data[0])-i+1):
 if j &gt; len(substr) and is_subseq_of_any(data[0][i:i+j], data):
 substr = data[0][i:i+j]
 return substr

def is_subseq_of_any(find, data):
 if len(data) &lt; 1 and len(find) &lt; 1:
 return False
 for i in range(len(data)):
 if not is_subseq(find, data[i]):
 return False
 return True

# Will also return True if possible_subseq == seq.
def is_subseq(possible_subseq, seq):
 if len(possible_subseq) &gt; len(seq):
 return False
 def get_length_n_slices(n):
 for i in xrange(len(seq) + 1 - n):
 yield seq[i:i+n]
 for slyce in get_length_n_slices(len(possible_subseq)):
 if slyce == possible_subseq:
 return True
 return False

print get_longest_common_subseq([[1, 2, 3, 4, 5], [2, 3, 4, 5, 6]])

print get_longest_common_subseq(['Oh, hello, my friend.',
 'I prefer Jelly Belly beans.',
 'When hell freezes over!'])
</code></pre>

blocks|key|307935|text|这可以用更短的时间完成：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|307936|def+long_substr(data):
++substrs+=+lambda+x:+{x[i:i%2Bj]+for+i+in+range(len(x))+for+j+in+range(len(x)+-+i+%2B+1)}
++s+=+substrs(data[0])
++for+val+in+data[1:]:
++++s.intersection_update(substrs(val))
++return+max(s,+key=len)|code-block|syntax|javascript|307937|set(可能)被实现为hash-map，这使得这有点低效。如果(1)将set数据类型实现为trie，(2)仅将后缀存储在trie中，然后强制每个节点成为端点(这相当于添加所有子字符串)，那么从理论上讲，我会猜测这个小工具非常有效地利用内存，特别是因为尝试的交集非常容易。|307938|然而，这是短暂的，过早的优化是浪费大量时间的根源。|307939|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This can be done shorter:

<pre class="lang-py prettyprint-override"><code>def long_substr(data):
 substrs = lambda x: {x[i:i+j] for i in range(len(x)) for j in range(len(x) - i + 1)}
 s = substrs(data[0])
 for val in data[1:]:
 s.intersection_update(substrs(val))
 return max(s, key=len)
</code></pre>

set's are (probably) implemented as hash-maps, which makes this a bit inefficient. If you (1) implement a set datatype as a trie and (2) just store the postfixes in the trie and then force each node to be an endpoint (this would be the equivalent of adding all substrings), THEN in theory I would guess this baby is pretty memory efficient, especially since intersections of tries are super-easy.

Nevertheless, this is short and premature optimization is the root of a significant amount of wasted time.

blocks|key|307945|text|我的回答是，速度很慢，但很容易理解。处理包含100个字符串(每个字符串大小为1+kb+)的文件大约需要两秒钟，如果有多个字符串，则返回任意一个最长的子字符串|type|unstyled|depth|inlineStyleRanges|entityRanges|data|307946|ls+=+list()
ls.sort(key=len)
s1+=+ls.pop(0)
maxl+=+len(s1)|code-block|syntax|javascript|307947|#1创建一个按长度倒序排列的所有子字符串的列表。因此，我们不必检查整个列表。|307948|subs+=+[s1[i:j]+for+i+in+range(maxl)+for+j+in+range(maxl,i,-1)]
subs.sort(key=len,+reverse=True)|307949|#2检查具有下一个最短字符串的子串，如果不在任何下一个最短字符串中，然后打破循环，这是不常见的。如果它通过了所有检查，默认是最长的一个，打破循环。|307950|def+isasub(subs,+ls):
++++for+sub+in+subs:
++++++++for+st+in+ls:
++++++++++++if+sub+not+in+st:
++++++++++++++++break+
++++++++else:
++++++++++++return+sub
++++++++++++break
print('the+longest+common+substring+is:+',isasub(subs,ls))|307951|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

My answer, pretty slow, but very easy to understand. Working on a file with 100 strings of 1 kb each takes about two seconds, returns any one longest substring if there are more than one
<pre><code>ls = list()
ls.sort(key=len)
s1 = ls.pop(0)
maxl = len(s1)
</code></pre>
#1 create a list of all substrings backwards sorted by length. Thus we don't have to check the whole list.
<pre><code>subs = [s1[i:j] for i in range(maxl) for j in range(maxl,i,-1)]
subs.sort(key=len, reverse=True)
 
</code></pre>
#2 Check a substring with the next shortest then the next etc. if is not in an any next shortest string then break the cycle, it's not common. If it passes all checks, it is the longest one by default, break the cycle.
<pre><code>def isasub(subs, ls):
 for sub in subs:
 for st in ls:
 if sub not in st:
 break 
 else:
 return sub
 break
print('the longest common substring is: ',isasub(subs,ls))
</code></pre>

blocks|key|3042860|text|Caveman解决方案，它将根据您作为列表传递的子串长度，为您提供一个数据帧，其中包含字符串中最频繁的子串：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3042861|import+pandas+as+pd

lista+=+['How+much+wood+would+a+woodchuck','+chuck+if+a+woodchuck+could+chuck+wood?']

string+=+''
for+i+in+lista:
++++string+=+string+%2B+'+'+%2B+str(i)

string+=+string.lower()

characters_you_would_like_to_remove_from_string+=+['+','-','_']

for+i+in+charecters_you_would_like_to_remove_from_string:
++++string+=+string.replace(i,'')

substring_length_you_want_to_check+=+[3,4,5,6,7,8]

results_list+=+[]

for+string_length+in+substring_length_you_want_to_check:
++++for+i+in+range(len(string)):
++++++++checking_str+=+string[i:i%2Bstring_length]
++++++++if+len(checking_str)+==+string_length:
++++++++++++number_of_times_appears+=+(len(string)+-+len(string.replace(checking_str,'')))/string_length
++++++++++++results_list+=+results_list%2B[[checking_str,number_of_times_appears]]


df+=+pd.DataFrame(data=results_list,columns=['string','freq'])

df['freq']+=+df['freq'].astype('int64')

df+=+df.drop_duplicates()


df+=+df.sort_values(by='freq',ascending=False)

display(df[:10])|code-block|syntax|javascript|3042862|结果是：|3042863|++++string++freq
78++++huck+++++4
63++++wood+++++4
77++++chuc+++++4
132++chuck+++++4
8++++++ood+++++4
7++++++woo+++++4
21+++++chu+++++4
23+++++uck+++++4
22+++++huc+++++4
20+++++dch+++++3|3042864|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Caveman solution that will give you a dataframe with the top most frequent substring in a string base on the substring length you pass as a list:
<pre><code>import pandas as pd

lista = ['How much wood would a woodchuck',' chuck if a woodchuck could chuck wood?']

string = ''
for i in lista:
 string = string + ' ' + str(i)

string = string.lower()

characters_you_would_like_to_remove_from_string = [' ','-','_']

for i in charecters_you_would_like_to_remove_from_string:
 string = string.replace(i,'')

substring_length_you_want_to_check = [3,4,5,6,7,8]

results_list = []

for string_length in substring_length_you_want_to_check:
 for i in range(len(string)):
 checking_str = string[i:i+string_length]
 if len(checking_str) == string_length:
 number_of_times_appears = (len(string) - len(string.replace(checking_str,'')))/string_length
 results_list = results_list+[[checking_str,number_of_times_appears]]


df = pd.DataFrame(data=results_list,columns=['string','freq'])

df['freq'] = df['freq'].astype('int64')

df = df.drop_duplicates()


df = df.sort_values(by='freq',ascending=False)

display(df[:10])

</code></pre>
result is:
<pre><code> string freq
78 huck 4
63 wood 4
77 chuc 4
132 chuck 4
8 ood 4
7 woo 4
21 chu 4
23 uck 4
22 huc 4
20 dch 3
</code></pre>

blocks|key|307969|text|在我的机器上，添加一个'break‘大大提高了jtjacques的回答速度(对于16K文件，速度大约是原来的1000倍)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|307970|def+long_substr(data):
++++substr+=+''
++++if+len(data)+>+1+and+len(data[0])+>+0:
++++++++for+i+in+range(len(data[0])):
++++++++++++for+j+in+range(len(substr)%2B1,+len(data[0])-i%2B1):
++++++++++++++++if+all(data[0][i:i%2Bj]+in+x+for+x+in+data[1:]):
++++++++++++++++++++substr+=+data[0][i:i%2Bj]
++++++++++++++++else:
++++++++++++++++++++break
++++return+substr|code-block|syntax|javascript|307971|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The addition of a single 'break' speeds up jtjacques's answer significantly on my machine (1000X or so for 16K files):
<pre><code>def long_substr(data):
 substr = ''
 if len(data) &gt; 1 and len(data[0]) &gt; 0:
 for i in range(len(data[0])):
 for j in range(len(substr)+1, len(data[0])-i+1):
 if all(data[0][i:i+j] in x for x in data[1:]):
 substr = data[0][i:i+j]
 else:
 break
 return substr
</code></pre>

I'm looking for a Python library for finding the longest common sub-string from a set of strings. There are two ways to solve this problem:
<ul>
<li>using suffix trees</li>
<li>using dynamic programming.</li>
</ul>
Method implemented is not important. It is important it can be used for a set of strings (not only two strings).

Longest common substring from more than two strings

Python

我正在寻找一个Python库，用于从一组字符串中找到最长的公共子字符串。有两种方法可以解决这个问题：using suffix treesusing dynamic programming。实现的方法并不重要。它可以用于一组字符串(而不仅仅是两个字符串)，这一点很重要。

问来自两个以上字符串的最长公用子字符串
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问来自两个以上字符串的最长公用子字符串EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问来自两个以上字符串的最长公用子字符串
EN