算法题：求一个序列S中全部包含T的子序列（distinct sub sequence）

题：

给定一个序列S以及它的一个子序列T，求S的全部包含T的子序列。例：

S = [1, 2, 3, 2, 4]

T = [1, 2, 4]

则S的全部包含T的子序列为：

[1, 2, 3, 2, 4]

[1, 2, 3, 4]

[1, 2, 2, 4]

[1, 2, 4]

 

解：

首先能够拆解为两个问题：

1. 求S的全部子序列；其中又涉及到去重的问题。

2. 求S的全部子序列中包含T的子序列。

 

暂时先不考虑去重，看看问题1怎么解：

1、求S的子序列

单纯求一个序列的全部子序列的话，就是求序列的全部组合。通常的思路为：S中每一个元素有输出和不输出两种状态，解集为全部元素是否输出的状态组合。因为两个元素有两种状态，因此解集的大小就是2的n次方（n为S的长度），也就是一个长度为n的二进制序列的全部可能值。因此求全部子序列的代码：

 

void PrintDistinctSubByFlags(char* seq, int seq_len, bool* seq_flags)
{
    printf("\r\n");
    char buf[] = "  ";
    for (int i = 0; i < seq_len; ++i)
    {
        if (seq_flags[i])
        {
            buf[0] = seq[i];
            printf(buf);
        }
    }
}
 
void DistinctSubInner(char* seq, int seq_len, bool* seq_flags, int seq_flags_idx)
{
    if (seq_flags_idx >= seq_len)
    {
        PrintDistinctSubByFlags(seq, seq_len, seq_flags);
        return;
    }
 
    seq_flags[seq_flags_idx] = false;
    DistinctSubInner(seq, seq_len, seq_flags, seq_flags_idx + 1);
    seq_flags[seq_flags_idx] = true;
    DistinctSubInner(seq, seq_len, seq_flags, seq_flags_idx + 1);
}
 
void DistinctSub(char* whole_seq)
{
    if(!whole_seq || !*whole_seq)
    {
        return;
    }
 
    bool* seq_flags = new bool[strlen(whole_seq) + 1];
    DistinctSubInner(whole_seq, strlen(whole_seq), seq_flags, 0);
    delete seq_flags;
}

 

 

能够换一个方式来写，不使用位数组标记，而是从序列的首元素开始处理，分输出和不输出两种状况，再递归处理首元素以外的子序列，这样能够直接生成输出序列（只包含要输出的元素）：

 

void DistinctSubInner(char* whole_seq, char* sub_seq, int sub_seq_len)
{
    if (!*whole_seq)
    {
        PrintDistinctSub(sub_seq_len);
        return;
    }
 
    sub_seq[sub_seq_len] = *whole_seq;
    DistinctSubInner(whole_seq + 1, sub_seq, sub_seq_len + 1); // output head of S
    DistinctSubInner(whole_seq + 1, sub_seq, sub_seq_len); // not ouput head of S
}
 
void DistinctSub(char* whole_seq)
{
    if(!whole_seq || !*whole_seq)
    {
        return;
    }
 
    sub_seq = new char[strlen(whole_seq)];
    DistinctSubInner(whole_seq, sub_seq, 0);
    delete sub_seq;
}

 

 

在这个基础上，能够再加入子序列的匹配逻辑：

2、求S中全部包含T的子序列

 

void DistinctSubInner(char* whole_seq, char* min_seq, char* sub_seq, int sub_seq_len)
{
    if (!*whole_seq)
    {
        if(!*min_seq)
        {
             PrintDistinctSub(sub_seq, sub_seq_len);
        }
        else
        {
             // unmatch sub sequence
        }
        return;
    }
 
    sub_seq[sub_seq_len] = *whole_seq;
 
    if (*whole_seq == *min_seq)
    {
         // 1. output head of S and match head of T
         DistinctSubInner(whole_seq + 1, min_seq + 1, sub_seq, sub_seq_len + 1);
    }
 
    // 2. output head of S but do not match head of T
    DistinctSubInner(whole_seq + 1, min_seq, sub_seq, sub_seq_len + 1);
 
    // 3. do not ouput head of S 
    DistinctSubInner(whole_seq + 1, min_seq, sub_seq, sub_seq_len);
}
 
void DistinctSub(char* whole_seq, char* min_seq)
{
    if(!whole_seq || !*whole_seq || !min_seq || !*min_seq)
    {
         return;
    }
 
    char* sub_seq = new char[strlen(whole_seq) + 1];
    DistinctSubInner(whole_seq, min_seq, sub_seq, 0);
    delete sub_seq;
}

 

 

 

这里S的首元素是否输出和是否和T的首元素进行匹配一共有三种组合：

1. S的首元素输出，可是不和T的首元素匹配（不相同没法匹配或故意不匹配）；

2. S的首元素输出，且S的首元素与T的首元素相同，进行匹配；

3. S的首元素不输出。

 

若是S的首元素不输出的话，天然就不能和T进行匹配，因此没有第4种可能。

 

那么，这里有一个问题，若是S的首元素和T的首元素相同时，为何要分匹配和不匹配两种状况呢？缘由在于若是S中包含两个相同的元素可以进行匹配的话，这么作可使T中对应元素可以匹配到S中的不一样位置，从而造成。

 

接下来再考虑重复元素的问题。

 

3、去重

我看到的重复问题有两类：

1. 若是S中有多个位置可以匹配T中某一个元素的话，是否须要匹配不一样位置？

2. 当已生成的输出序列中有连续两个相同的元素时，会造成重复解。

 

分开来看。

3.1 是否须要匹配不一样位置？

这其实也是两个子问题：

a. 匹配不一样位置会不会形成重复的解？

 

以S=[1,2,3,2,4], T=[1,2,4]为例。T中第2个元素能够匹配到S的第2和第4个位置。

显然，在S中两个可选匹配位置（第2和第4）之间的区域（此例中第3个元素）不输出的状况下，匹配到这两个位置的结果集是相同的，因此匹配到不一样位置会有重复解。

 

b. 只匹配单一位置的话会不会形成漏解？

 

若是只匹配S中的第一个可选位置的话，那么输出解的组合能够更改成：

1. 输出S的首元素，而且若是S的首元素与T的首元素相同，就匹配；

2. 不输出S的首元素。

 

这样问题就转换成了：这样一个逻辑造成的解空间，可否够覆盖将T中元素匹配到其它位置造成的解空间？为了解答这个问题，咱们须要再回到用位数组来表示解的表达方式。若是S中某个元素被匹配的话，那么它一定是要输出的，解空间相似：

{x,x,x,x,1,x,x...} // x表示状态未定0|1，0表示不输出，1表示输出；

 

以上面的例子来讲：

若是T中第2个元素匹配S中的第2个元素，解空间为： {1,1,x,x,1} & {1,0,x,1,1} = {1,x,x,x,1}

若是T中第2个元素匹配S中的第4个元素，解空间为： {1,x,x,1,1}，显然是{1,x,x,x,1}的子集。

 

因此，结论是只须要S中的任何一个位置便可。

 

这样程序就变成了：

 

void DistinctSubInner(char* whole_seq, int sub_seq_len)
{
    if (!*whole_seq)
    {
        if(!*min_seq)
        {
             PrintDistinctSub(sub_seq_len);
        }
        return;
    }
 
    sub_seq[sub_seq_len] = *whole_seq;
 
    if (*whole_seq == *min_seq)
    {
        DistinctSubInner(whole_seq + 1, min_seq + 1, sub_seq_len + 1);
    }
    else
    {
        DistinctSubInner(whole_seq + 1, min_seq, sub_seq_len + 1);
    }
 
    DistinctSubInner(whole_seq + 1, sub_seq_len);
}

 

 

3.2 如何解决连续相同元素形成的重复解？

以[1, 1]例，它的子序列为：

[1, 1]

[1]    只输出第一个元素

[1]    只输出第二个元素

 

解决此问题的一个简单的作法是，若是序列中有连续相同的元素，则在第一个元素输出的状况下，忽略第二个元素不输出的解。

 

void DistinctSubInner(char* whole_seq, int sub_seq_len)
{
    if (!*whole_seq)
    {
        if(!*min_seq)
        {
             PrintDistinctSub(sub_seq_len);
        }
        return;
    }
 
    sub_seq[sub_seq_len] = *whole_seq;
 
    if (*whole_seq == *min_seq)
    {
        DistinctSubInner(whole_seq + 1, min_seq + 1, sub_seq_len + 1);
    }
    else
    {
        DistinctSubInner(whole_seq + 1, min_seq, sub_seq_len + 1);
    }
 
    if(sub_seq[sub_seq_len] != sub_seq[sub_seq_len - 1])
    {
        DistinctSubInner(whole_seq + 1, min_seq, sub_seq_len);
    }
}

 

 

须要注意的是，不能在S上做这个判断，由于形如[1,2,1]的序列，虽然两个1不连续，但在2不输出的状况下，一样会造成重复解。因此只能在生成的结果序列上做处理。

 

事实上，S中可能不仅是包含两个相同的元素，还可能包含两个相同的子序列，例如[1,2,1,2]，上面的逻辑彷佛并不能防止造成重复的[1,2]解。可是，颇有趣的是，上面代码就是不会致使造成重复的子序列解。为何？请跟我同样看下测试结果的输出，大概就能看出原委了，这个已经不知道怎么表达了...

 

因此，暂时的解就是这样。补上测试代码：

 

int main(int argc, _TCHAR* argv[])
{
    char* whole_seqs[] = {
    "1",
    "124",
    "1234",
    "1124",
    "1224",
    "1244",
    "12324",
    "135635624",
    "1323245",
    "13523524",};
 
    for (int i = 0; i < sizeof(whole_seqs) / sizeof(char*); ++i)
    {
        printf("\r\n\r\ndistinct sub sequence of \"%s\" for \"%s\" : ===============", whole_seqs[i], "124");
        DistinctSub(whole_seqs[i], "124");
    }
 
    getchar();
}
 

 

后话

 

做为一个算法的话，这显然不能说over了。

首先，算法的正确性，应该作做大量的测试验证。譬如，还有没有没有想到的重复解的状况？对于这个算法，我并无十分的把握，还须要验证来发现问题并确认正确性。

其次，在去重这一块，我以为个人思路彷佛并不直观，以及并无和数学里的问题应对起来。而现实中不少算法其实都能转换为数学问题。因此我怀疑有更简洁和明了的思路。

上午百度了一下，网上有一堆人问这个，想必应该是别的思路的，不过我仍是先把个人思路记下来。再去学习。

 

顺便再吐槽一下，博客园的编辑器依然烂成翔...等宽代码字体都没有，代码缩进又被吃了。有个高亮的功能聊胜于无吧...本地纯文本或markdown可是consolas+雅黑字体好太多了，线上的就只能将就看下。