最长不重复子序列_最长重复子序列-CSDN博客

最长不重复子序列

Description:

描述：

This question has been featured in interview rounds of Amazon.

这个问题已在亚马逊的采访回合中提到。

Problem statement:

问题陈述：

Given string str, find the length of the longest repeating subsequence such that the two subsequences don't have the same character in the same position, i.e., any i^th character in the two sub-sequences shouldn't have the same index in its original string.

给定字符串str ，求出最长重复子序列的长度，以使两个子序列在相同位置没有相同的字符，即，两个子序列中的任何^第 i ^个字符在其位置均不应具有相同的索引原始字符串。

    Let the string be,
    Str="includehelpisbest"
    
    Output will be:
    Longest repeating sub-sequence length is 3
    The longest repeating sub-sequence is:"ies"

The output is given above where the repeating sub-sequences are in two different colours. One more repeating subs-sequence can be,

上面给出了输出，其中重复子序列使用两种不同的颜色。可以再重复一个子序列，

Solution Approach:

解决方法：

The problem can be solved in similar way as longest Common subsequence problem, where input to LCS() would be String str both the case. That is

可以通过与最长公共子序列问题类似的方法来解决该问题，在这两种情况下， LCS()的输入均为String。那是

    LRS(str) = LCS(str,str) which some constraints

Let's discuss the recursive approach first.

让我们首先讨论递归方法。

Let,

让，

    
    l = Length of the  string,str
    f(l,l) = Longest repeating subsequence length for string length l

Now,

现在，

Think of the following example,

考虑以下示例，

Say the string is: x₁x₂...x_l

假设字符串是： x ₁ x ₂ ... x _l

Say,

说，

x_i==x_j and i≠j (this is the constraint what we discussed above)

x _i == x _j和i≠j (这是我们上面讨论的约束)

Then obviously we need to find LCS for the remaining part of string (x₁x₂...x_i-1, x₁x₂...x_j-1) and then add 1 for this valid character match (repeating character match),

那么显然我们需要为字符串的其余部分(x ₁ x ₂ ... x _i-1 ，x ₁ x ₂ ... x _j-1 )找到LCS，然后为这个有效的字符匹配添加1(重复字符比赛)，

Else

其他

Maximum of two case,

最多两种情况

LCS of the string leaving character x_i,x₁x₂...x_i-1 and string x₁x₂...x_j.
字符串x _i ，x ₁ x ₂ ... x _i-1和字符串x ₁ x ₂ ... x _j的 LCS。
LCS of the string x_l₁, x₁x₂...x_i and second string leaving character x_j,x₁x₂...x_j-1
字符串x _{l ₁} ，x ₁ x ₂ ... x _i的 LCS和第二个字符串剩下的字符x _j ，x ₁ x ₂ ... x _j-1

Now, we need to recur down to 0. So,

现在，我们需要递归降至0。因此，

Where base cases are,

在基本情况下，

    f(0,i)=0 for 0≤i≤l
    f(i,0)=0 for 0≤i≤ l

If you generate this recursion tree, it will generate many overlapping sub-problems and thus, we need to reduce the re-computing. That's why we need to convert it into dynamic programming where we will store the output of the sub-problems and we will use it to compute bigger sub-problems.

如果生成此递归树，它将生成许多重叠的子问题，因此，我们需要减少重新计算。这就是为什么我们需要将其转换为动态编程，以便在其中存储子问题的输出，并使用它来计算更大的子问题。

Converting to Dynamic programming:

转换为动态编程：

    1)  Initialize dp[l+1][l+1]  to 0
    2)  Convert the base case of recursion:
        for i=0 to l
            dp[i][0]=0;
        for i=0 to l
            dp[0][i]=0;

    3)  Fill the DP table as per recursion.
        for i=1 to l    //i be the subproblem length for first string of LCS
            for j=1 to l //j be the subproblem length for second string of LCS
                if(i≠j and str1[i-1]==str2[j-1]) //xi==xj  and i≠j
                    dp[i][j]=dp[i-1][j-1]+1;
                else
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            end for
        end for  
    4)  The final output will be dp[l][l]

C++ Implementation:

C ++实现：

#include <bits/stdc++.h>
using namespace std;

void print(vector<int> a, int n)
{
    for (int i = 0; i < n; i++)
        cout << a[i] << " ";
    cout << endl;
}

int max(int a, int b)
{
    return (a > b) ? a : b;
}

int LRS(string str1, string str2)
{
    int l = str1.length();
    int dp[l + 1][l + 1];

    //base case
    for (int i = 0; i <= l; i++)
        dp[i][0] = 0;
	
    for (int i = 0; i <= l; i++)
        dp[0][i] = 0;
	
    //fill up
    for (int i = 1; i <= l; i++) {
        for (int j = 1; j <= l; j++) {
            if (i != j && str1[i - 1] == str2[j - 1])
                dp[i][j] = dp[i - 1][j - 1] + 1;
            else
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
        }
    }

    return dp[l][l];
}

int main()
{
    string str;

    cout << "Enter the string:\n";
    cin >> str;
    cout << "Longest repeating sub-sequence length: " << LRS(str, str) << endl;

    return 0;
}

Output

输出量

Enter the string:
includehelpisbest
Longest repeating sub-sequence length: 3

翻译自: https://www.includehelp.com/icp/longest-repeating-subsequence.aspx

最长不重复子序列