算法题:求一个序列S中所有包含T的子序列(distinct sub sequence)

Posted 做镜观天

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了算法题:求一个序列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怎么解:

一、求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;
}

 

 
在这个基础上,可以再加入子序列的匹配逻辑:

二、求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中的不同位置,从而形成。
 
接下来再考虑重复元素的问题。
 

三、去重

我看到的重复问题有两类:
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+雅黑字体好太多了,线上的就只能将就看下。
 

以上是关于算法题:求一个序列S中所有包含T的子序列(distinct sub sequence)的主要内容,如果未能解决你的问题,请参考以下文章

#yyds干货盘点# leetcode算法题:判断子序列

求序列完美度(trie+贪心)

51nod 1255 字典序最小的子序列

LeetCode第115题—不同的子序列—Python实现

poj 水题1936 求指教。给定两个字符串s,t。判断s是不是是t的子序列。(t中字符可删减,但顺序不变)

CF1492C - Maximum width