从子字符串中优化字符串的算法

Question

假设我有一个子字符串的集合，例如：

string a = {"cat","sensitive","ate","energy","tense"}

那么输出应该如下：

catensesensitivenergy

我该怎么做？

Answer 1

分解问题，看看我们得到了什么。仅从两个字符串开始。我们必须检查一个字符串的哪个后缀是另一个字符串的最长前缀。这为我们提供了最佳连接的顺序。

现在，有了一组n字，我们怎么办？我们首先构建一个包含每个单词（每个单词的键）的 trie。如果一个词与另一个词重复，我们可以在构建前缀树时轻松地标记它。

我快速实现了一个常规的 Trie。你可以找到它here。

我们拥有构建一个有向图的工具，将不同的词联系起来，无论第一个词的后缀是第二个词的前缀。边的权重就是后缀的长度。

为此，对于输入集的每个单词w，我们必须看看我们可以使用后缀w到达哪些单词：

• 我们使用后缀沿着树向下走。我们最终会进入一个节点（或不是）。
• 从这个节点，如果它存在，我们扫描剩余的子树，看看哪些词是 可用的。
  • 如果给定的长度为 l 的后缀产生与 词的前缀w'，然后我们添加一条边w → w'，权重length(w') - l。
  • 如果这样的边缘已经存在，我们只需更新权重以保持最低。

从那里开始，图就设置好了，我们必须找到通过每个顶点（例如单词）只运行一次的最短路径。如果图表完整，则为Traveling Salesman Problem。大多数情况下，图表并不完整。

不过，这仍然是一个 NP 难题。用更多的“技术”术语来说，手头的问题是找到the shortest hamiltonian path of a digraph。

注意：给定一条哈密顿路径（如果存在），成本为 C，起始顶点（单词）为 W，超字符串长度由下式给出：

L_超 = L_W + C

注意：如果两个词没有后缀将它们链接到另一个词，则图不连通，不存在哈密顿路径。

Answer 2

这个问题被称为最短的普通超弦问题，它是 NP 难的，所以如果你需要一个精确的解决方案，那么尝试所有可能性并选择最好的解决方案是再好不过的了。

一种可能的指数解决方案是生成输入字符串的所有排列，为每个排列贪婪地找到最短的公共超串（排列指定字符串的顺序，并且可以证明对于固定顺序的贪婪算法总是正确工作) 并选择最佳的。

Answer 3

使用 user2040251 建议：

#include <string>
#include <iostream>
#include <algorithm>

std::string merge_strings( const std::vector< std::string > & pool )
{
    std::string retval;
    for( auto s : pool )
        if( retval.empty() )
            retval.append( s );
        else if( std::search( retval.begin(), retval.end(), s.begin(), s.end() ) == retval.end() )
        {
            size_t len = std::min( retval.size(), s.size() ); 
            for( ; len; --len )
                if( retval.substr( retval.size() - len ) == s.substr( 0, len ) )
                {
                    retval.append( s.substr( len ) );
                    break;
                }
            if( !len )
                retval.append( s );
        }
    return retval;           
}

std::string shortest_common_supersequence( std::vector< std::string > & pool )
{
    std::sort( pool.begin(), pool.end() );

    std::string buffer;
    std::string best_reduction = merge_strings( pool );
    while( std::next_permutation( pool.begin(), pool.end() ) )
    {
        buffer = merge_strings( pool );
        if( buffer.size() < best_reduction.size() )
            best_reduction = buffer;
    }
    return best_reduction;
}


int main( int argc, char ** argv )
{
    std::vector< std::string > a{"cat","sensitive","ate","energy","tense"};
    std::vector< std::string > b{"cat","sensitive","ate","energy","tense","sit"};
    std::vector< std::string > c{"personal","ate","energy","tense","gyroscope"};
    std::cout << "best a --> \"" << shortest_common_supersequence( a ) << "\"\n";
    std::cout << "best b --> \"" << shortest_common_supersequence( b ) << "\"\n";
    std::cout << "best c --> \"" << shortest_common_supersequence( c ) << "\"\n";

    return 0;
}

输出：

best a --> "catensensitivenergy"
best b --> "catensensitivenergy"
best c --> "atensenergyroscopersonal"