题目来自LeetCode，链接：单词的压缩编码。具体描述为：给定一个单词列表，我们将这个列表编码成一个索引字符串 S 与一个索引列表 A。例如，如果这个列表是 [“time”, “me”, “bell”]，我们就可以将其表示为 S = “time#bell#” 和 indexes = [0, 2, 5]。对于每一个索引，我们可以通过从字符串 S 中索引的位置开始读取字符串，直到 “#” 结束，来恢复我们之前的单词列表。那么成功对给定单词列表进行编码的最小字符串长度是多少呢？
示例：
输入: words = ["time", "me", "bell"]
输出: 10
说明: S = "time#bell#" ， indexes = [0, 2, 5] 。
首先很容易想到的还是暴力法，我们先给列表按照字符串的长度排序（从长到短排序），因为一个字符串可以独立出来作为一个XXX#的格式的话必定不能是前面某个比它还长的字符串的后缀，否则就可以给整合到前面的字符串里面去了，而因为字符串已经排序，所以在遍历字符串的过程中，只需要判断当前字符串是否为之前遍历过的字符串中某一个的后缀就好了。
JAVA版代码如下：
class Solution {
public int minimumLengthEncoding(String[] words) {
Arrays.sort(words, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s2.length() - s1.length();
}
});
List<String> SList = new LinkedList<>();
int result = 0;
for (String s : words) {
boolean isEnd = false;
for (String longerStr : SList) {
if (longerStr.endsWith(s)) {
isEnd = true;
break;
}
}
if (!isEnd) {
result += s.length() + 1;
SList.add(s);
}
}
return result;
}
}
提交结果如下:
毫无疑问的效率不咋地。因为在判断一个字符串是否之前某个较长字符串的后缀上会用去很多时间，所以这里可以继续优化，一种想法就是用一个set保存我们遍历过的字符串的所有可能后缀（比如字符串为abc，就会有后缀abc、bc和c），然后之后再遇到更短的字符串只需要到set中查看是否有当前字符串即可。
JAVA版代码如下：
class Solution {
public int minimumLengthEncoding(String[] words) {
Arrays.sort(words, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s2.length() - s1.length();
}
});
Set<String> set = new HashSet<>();
int result = 0;
for (String s : words) {
if (!set.contains(s)) {
result += s.length() + 1;
for (int i = 0; i < s.length(); ++i) {
set.add(s.substring(i));
}
}
}
return result;
}
}
提交结果如下:
果然效率提升了不少，这也主要是因为题目限定每个单词的长度不超过7，所以找出所有后缀的操作并不是很费时。不过还是不够高效，因为前面还有个排序的过程。那怎么才可以去掉排序的过程呢，考虑到排序是为了方便后面的加入set，那么反过来，改为从set中去除后缀便可以不用排序了。具体就是先将列表中所有字符串加入到一个set中，然后遍历列表中的字符串，看当前字符串的所有后缀（这个时候不包括其本身了）是否在set中，是的话说明在set中的这个字符串就是当前字符串的后缀，可以从set中去掉这个字符串了。
记第i个字符串的长度为 ，则判断每个字符串是否存在于set中需要 （计算hash值），所以总的时间复杂度为 。空间复杂度就是set的大小即 。
JAVA版代码如下：
class Solution {
public int minimumLengthEncoding(String[] words) {
Set<String> set = new HashSet<>(Arrays.asList(words));
for (String s : words) {
for (int i = 1; i < s.length(); ++i) {
set.remove(s.substring(i));
}
}
int result = 0;
for (String s : set) {
result += s.length() + 1;
}
return result;
}
}
提交结果如下:
Python版代码如下：
class Solution:
def minimumLengthEncoding(self, words: List[str]) -> int:
wordSet = set(words)
for word in words:
for i in range(1, len(word)):
wordSet.discard(word[i:])
return sum(len(word) + 1 for word in wordSet)
提交结果如下:
再者参看官方解答，还可以有字典树的解法，可以把时间复杂度进一步减到 。
JAVA版代码如下：
class Solution {
public int minimumLengthEncoding(String[] words) {
TrieNode root = new TrieNode();
Map<TrieNode, Integer> map = new HashMap<>();
for (String word : words) {
int i = word.length() - 1;
TrieNode node = root.get(word.charAt(i));
for (--i; i >= 0; --i) {
node = node.get(word.charAt(i));
}
map.put(node, word.length() + 1);
}
int result = 0;
for (TrieNode node : map.keySet()) {
if (node.isLeaf) {
result += map.get(node);
}
}
return result;
}
}
class TrieNode {
TrieNode[] children;
boolean isLeaf;
public TrieNode() {
children = new TrieNode[26];
isLeaf = true;
}
public TrieNode get(char c) {
if (children[c - 'a'] == null) {
children[c - 'a'] = new TrieNode();
isLeaf = false;
}
return children[c - 'a'];
}
}
提交结果如下:
