Longest string that can be made out of a list of strings - algorithm

Question

I'm looking for an efficient algorithm which will give me the longest string which can be made out of a list of strings. More precisely:
Given a file containing large number of strings, find the longest string from the list of strings presented in the file, which is a concatenation of other one or more strings.
Note: The answer string should also belong to the list of strings in file.
Example input:
The
he
There
After
ThereAfter
Output:
ThereAfter

Answer 1

Sort list in descending length order for strings in the list (first in the list is longest string). Quicksort is sorting with average time complexity O(nlogn).
Then, iterate on strings in the list starting left.
From string S, iterate on elements s to its right. If s is a substring of S, remove s from S. Continue iterating to the right until S is empty, meaning that it is made of items of the list.
public static class ListCompare implements Comparator<String> {
public int compare(String s1, String s2) {
if (s1.length() < s2.length())
return 1;
else if (s1.length() > s2.length())
return -1;
else
return 0;
}
}
public static String longestSurString(String[] ss) {
Arrays.sort(ss, new ListCompare ());
for (String S: ss) {
String b = new String(s);
for (String s: ss) {
if (!s.equals(b) && S.contains(s)) {
S = S.replace(s, "");
}
}
if (S.length() == 0)
return b;
}
return null;
}

Answer 2

Let us number the strings from S1, S2, ..., Sn
If I understand the problem statement correctly, than for Sito be a candidate for an answer, it must be equal to the concatenation of some
Sj_1, Sj_2, ..., Sj_k where forall x in 1..k: i != j_x. That is Si must be the concatenation of a subset of the strings that it is not a member of.
Given that, add all the strings to a trie. This will find all the prefix pairs, that is all (Si, Sj_1) from the above. Removing the Sj_1 prefix from Si renders a new string T, that must either be equal to Sj_k, or can be similarly reduced by searching for Sj_2 in the trie.

Answer 3

Best Solution using Trie & HashMap data structure:
We need first store all string and then just check prefix which words length is more.
public class TrieNode {
private HashMap<Character, TrieNode> children;
private boolean isWord;
public TrieNode() {
children = new HashMap<>();
isWord = false;
}
public void add(String s) {
HashMap<Character,TrieNode> temp_child = children;
for(int i=0; i<s.length(); i++){
char c = s.charAt(i);
TrieNode trieNode;
if(temp_child.containsKey(c)){
trieNode = temp_child.get(c);
}else{
trieNode = new TrieNode();
temp_child.put(c, trieNode);
}
temp_child = trieNode.children;
//set leaf node
if(i==s.length()-1)
trieNode.isWord = true;
}
}
public boolean isWord(String s) {
TrieNode trieNode = searchNode(s);
if(trieNode != null && trieNode.isWord)
return true;
else
return false;
}
public TrieNode searchNode(String s){
HashMap<Character, TrieNode> temp_child = children;
TrieNode trieNode = null;
for(int i=0; i<s.length(); i++){
char c = s.charAt(i);
if(temp_child.containsKey(c)){
trieNode = temp_child.get(c);
temp_child = trieNode.children;
}else{
return null;
}
}
return trieNode;
}