JavaScript Count Distinct Occurrences as a Subsequence

Counting the distinct occurrences is the most common problem in string manipulation. Subsequences are the subsets of the characters in the string which appear in the same order but not necessarily in a consecutive manner. In the problem, the task is to find out the count of how many times a given subsequence appears as a distinct occurrence in the given larger string. In this article, we will explore various approaches to count distinct occurrences as a subsequence

There are different approaches to counting distinct occurrences as a subsequence in JavaScript. Let’s discuss each one of them.

Using Recursion with Memoization

• In this approach, we have defined the recursive function which finds the two possibilities at each step: whether the current characters in the string match or not.
• The memoization table is used to store the previously computed output results for the specific indices, and it ensures that there are no repeat calculations.
• Using this approach, we can traverse all possible combinations of characters and return the count of distinct occurrences of subsequences.

Example: In this example, we will count distinct occurrences as a subsequence using Recursion with Memoization approach

function countSeq(str, seq) {
    const memoTable = new Map();
    function helperFunction(strIdx, seqIdx) {
        if (seqIdx === seq.length) return 1;
        if (strIdx === str.length) return 0;
        const key = strIdx + ',' + seqIdx;
        if (memoTable.has(key)) return memoTable.get(key);
        let count = 0;
        if (str[strIdx] === seq[seqIdx]) {
            count += helperFunction(strIdx + 1, seqIdx + 1);
        }
        count += helperFunction(strIdx + 1, seqIdx);
        memoTable.set(key, count);
        return count;
    }
    return helperFunction(0, 0);
}

const str = "geeksforgeeks";
const seq = "ge";
console.log(countSeq(str, seq));

6

Time complexity: O(2 ^ N), where 'N' is the length of the input.

Auxiliary space: O(2 ^ N), The space complexity is determined by the space used for the memoTable, which is a Map data structure. Stores for all unique combinations of strIndex and subseqIndex.

Using String Iteration

• In this approach, we are creating a 2D array('dp') to store the counts of each step in which 'dp[i][j]' represents the count of each distinct subsequence of 'subseqInput' in the 1st 'i' characters of 'stringInput'.
• This approach iterates over both the input strings, comparing the characters and when the match is found.
• It adds the count from the previous characters with and without including the current character, this ensures that all possible distinct subsequences are computed.

Example: In this example, we will count distinct occurrences as a subsequence using the String Iteration approach.

function countSeq(str, seq) {
    const m = str.length;
    const n = seq.length;
    const dp = Array(m + 1).fill(0).map(() => Array(n + 1).fill(0));
    for (let i = 0; i <= m; i++) {
        dp[i][0] = 1;
    }
    for (let i = 1; i <= m; i++) {
        for (let j = 1; j <= n; j++) {
            if (str[i - 1] === seq[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
            } else {
                dp[i][j] = dp[i - 1][j];
            }
        }
    }

    return dp[m][n];
}
const str = "geeksforgeeks";
const pattern = "ge";
console.log(countSeq(str, pattern));

6

Time Complexity: O(M * N), where 'M' is the length of the strInput, and 'N' is the length of the subseqInput.

Auxiliary space: O(M * N), a two-dimensional array that stores the results of subproblems during dynamic programming.

Using BackTracking

• In this BackTracking Apporach, we are using the recursive backtracking algo that actually counts the nu,ber of distinct subsequence of the input 'subseqInput' in 'strInput'.
• Here, the algo iterates over all the possible cobinations off the characters in the 'strInput' to constrcut the subsequence that matches the 'subseqInput'.
• In the every step, either the current character from the 'strInput' is included in the subsequence that is formed or it is skiped.
• This recursion contniues till there is proper constrcution of subsequences that matches subseqInput, in that case we increment the count value or we reach to the end of the string.

Example: In this example, we will count distinct occurrences as a subsequence using the BackTracking approach.

function fun(str, subSeq) {
    function countSeq(strIndex, subseqIndex) {
        if (subseqIndex === subSeq.length) {
            count++;
            return;
        }
        if (strIndex === str.length) {
            return;
        }
        if (str[strIndex] === subSeq[subseqIndex]) {
            countSeq(strIndex + 1, subseqIndex + 1);
        }
        countSeq(strIndex + 1, subseqIndex);
    }
    let count = 0;
    countSeq(0, 0);
    return count;
}

const str = "geeksforgeeks";
const pattern = "ge";
console.log(fun(str, pattern));

6

Time Complexity: O(2^N), where 'N' is the lenthgo of 'strInput'.

Auxiliary space: O(N), where 'N' is the lenthgo of 'strInput'., due to the maximum depth of the recursive call stack, addition to constant space for varibaes and function call oerhead.

Dynamic Programming with Space Optimization

In this approach, instead of using a 2D array to store the counts of subsequences, we use a 1D array (or two 1D arrays) to keep track of the counts. This reduces the space complexity significantly while maintaining the time complexity.

The main idea is to use two arrays, current and previous, where current[j] represents the count of subsequences of subSeq in the first i characters of str and previous[j] represents the count for the previous row in the dynamic programming table.

Example:

function countSeqOptimized(str, seq) {
    const m = str.length;
    const n = seq.length;
    if (n > m) return 0; // If subseq length is greater than string length, return 0
    
    let previous = Array(n + 1).fill(0);
    let current = Array(n + 1).fill(0);
    previous[0] = 1; // Base case: an empty subsequence is a subsequence of any string

    for (let i = 1; i <= m; i++) {
        current[0] = 1; // Base case: an empty subsequence is a subsequence of any string
        for (let j = 1; j <= n; j++) {
            if (str[i - 1] === seq[j - 1]) {
                current[j] = previous[j - 1] + previous[j];
            } else {
                current[j] = previous[j];
            }
        }
        // Swap current and previous arrays
        [previous, current] = [current, previous];
    }

    return previous[n];
}

const str = "geeksforgeeks";
const seq = "ge";
console.log(countSeqOptimized(str, seq));

6

Time Complexity: O(MxN) O (M×N), where ? M is the length of str and ? N is the length of seq.

Auxiliary Space: O(N) O (N), because we are using two 1D arrays of size N+1.