从句子列表中获取最长的公共子字符串

Question

鉴于以下几行

                "Alberry K2503 F40 D",
                "Alberry K2503 F40 S",
                "Demi Deco Denver BLK",
                "Demi Deco Denver BRN",
                "Demi Deco Tank",
                "Demi Deco Audi",
                "Samsung S 19 S10",
                "Samsung S 19 S12"

我需要得到一个包含以下内容的列表

 Alberry K2503 F40
 Demi Deco Denver
 Demi Deco
 Samsung S 19

我试图以这种方式实现它。

    class TrieNode
    {
        public string Word { get; set; }

        public TrieNode Parent { get; set; }

        public Dictionary<string, TrieNode> Children { get; set; } = new Dictionary<string, TrieNode>();

        public override string ToString()
        {
            return $"{Word}";
        }
    }

    class Program
    {
        static string JoinSentence(TrieNode node)
        {
            List<string> sentence = new List<string>();
            while (node != null)
            {
                sentence.Insert(0, node.Word);
                node = node.Parent;
            }

            return string.Join(" ", sentence);
        }

        static void GetSentences(TrieNode node, HashSet<string> sentences)
        {
            if (node.Children.Count > 0)
            {
                foreach (var nodeChild in node.Children)
                {
                    GetSentences(nodeChild.Value, sentences);
                }
            }
            else
            {
                if (node.Parent.Children.Count == 1)
                {
                    sentences.Add(JoinSentence(node));
                }
                else
                {
                    bool lastChildren = false;
                    foreach (var child in node.Parent.Children)
                    {
                        if (child.Value != node)
                        {
                            if (child.Value.Children.Count > 0)
                            {
                                lastChildren = true;
                                sentences.Add(JoinSentence(node));
                                break;
                            }
                        }
                    }

                    if (!lastChildren)
                    {
                        sentences.Add(JoinSentence(node.Parent));
                    }
                }
            }
        }

        static void Main(string[] args)
        {
            var root = new TrieNode();
            var sentences = new[]
            {
                "Alberry K2503 F40 D",
                "Alberry K2503 F40 S",
                "Demi Deco Denver BLK",
                "Demi Deco Denver BRN",
                "Demi Deco Tank",
                "Demi Deco Audi",
                "Samsung S 19 S10",
                "Samsung S 19 S12"
            };

            foreach (var sentence in sentences)
            {
                var words = sentence.Split(' ');
                TrieNode node = null;
                foreach (var word in words)
                {
                    if (node == null)
                    {
                        if (root.Children.ContainsKey(word))
                        {
                            node = root.Children[word];
                        }
                        else
                        {
                            node = new TrieNode {Word = word, Parent = root};
                            root.Children.Add(word, node);
                        }
                    }
                    else
                    {
                        if (node.Children.ContainsKey(word))
                        {
                            node = node.Children[word];
                        }
                        else
                        {
                            node.Children.Add(word, node = new TrieNode {Word = word, Parent = node});
                        }
                    }
                }
            }

            var sentencesCommon = new HashSet<string>();

            GetSentences(root, sentencesCommon);
            foreach (var sentence in sentencesCommon)
            {
                Debug.WriteLine(sentence);
            }
        }
    }

它似乎可以工作，但缺少Demi Deco 的结果，其中Audi 和Tank 应被省略。 我想我真的搞砸了正确遍历树并获得独特的句子。看来我正在重新发明轮子。有人会推荐更好的解决方案吗？

谢谢

Answer 1

您要求最长的公共子字符串，您可以通过将每个字符串相互匹配来做到这一点。但是，您的预期输出表明您只想匹配整个单词，即最多匹配一个空格字符。这适用于您的示例测试数据：

public void Run()
{
    List<string> output = new List<string>();
    for (int i = 0; i < input.Count-1; ++i)
    {
        for (int j = i+1; j< input.Count; ++j)
        {
            string leftMatch = LeftMatch(input[i], input[j]);
            if (leftMatch.Length>0 && !output.Contains(leftMatch))
            {
                output.Add(leftMatch);
            }
        }
    }
    output.ForEach(x=>Console.WriteLine(x));
}
public string LeftMatch(string a, string b)
{
    string result = "";
    for ( int i=0; i<a.Length&& i<b.Length; ++i)
    {
        if (a[i] != b[i])
        {
            if (!result.Contains(" ")) return "";
            return result.Substring(0, result.LastIndexOf(" ", StringComparison.Ordinal));
        }
        result += a[i];
    }
    return result;
}
List<string> input =
new List<string>{
    "Alberry K2503 F40 D",
    "Alberry K2503 F40 S",
    "Demi Deco Denver BLK",
    "Demi Deco Denver BRN",
    "Demi Deco Tank",
    "Demi Deco Audi",
    "Samsung S 19 S10",
    "Samsung S 19 S12"
};

结果如下：

Alberry K2503 F40 
Demi Deco Denver
Demi Deco  
Samsung S 19