Count the sum of count of distinct characters present in all Substrings

Given a string S consisting of lowercase English letters of size N where (1 <= N <= 105), the task is to print the sum of the count of distinct characters N where (1 <= N <= 10⁵)in all the substrings.

Examples:

Input: str = "abbca"
Output: 28
Explanation: The following are the substrings of "abbca":
=> Sum of distinct characters in Substrings of length 1: "a", "b", "b", "c", "a" is 1 + 1 + 1 + 1 + 1 = 5
=> Sum of distinct characters in Substrings of length 2: "ab", "bb", "bc", "ca" is 2 + 1 + 2 + 2 = 7.
=> Sum of distinct characters in Substrings of length 3: "abb", "bbc", "bca" is 2 + 2 + 3 = 7.
=> Sum of distinct characters in Substrings of length 4: "abbc", "bbca" is 3 + 3 = 6.
=> Sum of distinct characters in Substrings of length 5: "abbca" is 3
The total count is 5 + 7 + 7 + 6 + 3 = 28

Input: str = "code"
Output: 20
Explanation: The following are the substrings of "code":
=> Sum of distinct characters in Substrings of length 1: "c", "o", "d", "e" is 1 + 1 + 1 + 1 = 4.
=> Sum of distinct characters in Substrings of length 2: "co", "od", "de" is 2 + 2 + 2 = 6.
=> Sum of distinct characters in Substrings of length 3: "cod", "ode" is 3 + 3 = 6.
=> Sum of distinct characters in Substrings of length 4: "code" is 4.
The total count is 4+ 6 + 6 + 4 = 20

Approach: To solve the problem follow the below idea:

The idea is to count the contribution of each character in different substrings. For each character ch, iterate through the entire string and for each index i, we will count the number of substrings ending at i and have at least one occurrence of ch. This can be simply done by keeping track of the last occurrence of ch.

• Initialize a variable result with 0 to store the answer.
• Iterates through each lowercase English alphabet character from 'a' to 'z'.
  • For each character, initializes a variable last_occur to -1, this will keep track of the position of the last occurrence of the current character in the string.
  • Iterates through input string S and checks if the S[i] matches the current character being considered.
    • If matches, it adds the 1-based index of the character to the result as these many substrings have at least one current alphabets and updates last_occur to the current position.
    • If not matches, it adds the position of the last occurrence of the current character (stored in last_occur) to the result.
• Final return the result

Below is the implementation of the above approach:

// C++ code for the above approach

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

// Function to calculate answer
// for a given string
long long fun(string s)
{

    // Get the length of the input string
    int n = s.size();

    // Initialize the result to 0
    long long result = 0;

    // Loop through each lowercase character
    for (char ch = 'a'; ch <= 'z'; ch++) {

        // Initialize the last occurrence of the
        // character to -1
        int last_occur = -1;

        // Loop through the input string
        for (int i = 0; i < n; i++) {
            if (s[i] == ch) {

                // If the current character matches
                // the current alphabet character,
                // add the position of the character
                // (1-based index) to the result
                result += (i + 1);

                // Update the last
                // occurrence position
                last_occur = i;
            }
            else {

                // If the current character
                // doesn't match the current
                // alphabet character, add the
                // position of the last occurrence
                // (if any) to the result
                result += (last_occur + 1);
            }
        }
    }

    // Return the final result
    return result;
}

// Drivers code
int main()
{

    // Define an input string
    string s = "abbca";

    // Call the function and print the result
    cout << fun(s);

    return 0;
}

// Java code for the above approach
public class GFG {

    // Function to calculate the answer for a given string
    static long fun(String s)
    {
        // Get the length of the input string
        int n = s.length();

        // Initialize the result to 0
        long result = 0;

        // Loop through each lowercase character
        for (char ch = 'a'; ch <= 'z'; ch++) {
            // Initialize the last occurrence of the
            // character to -1
            int lastOccur = -1;

            // Loop through the input string
            for (int i = 0; i < n; i++) {
                if (s.charAt(i) == ch) {
                    // If the current character matches the
                    // current alphabet character, add the
                    // position of the character (1-based
                    // index) to the result
                    result += (i + 1);

                    // Update the last occurrence position
                    lastOccur = i;
                }
                else {
                    // If the current character doesn't
                    // match the current alphabet character,
                    // add the position of the last
                    // occurrence (if any) to the result
                    result += (lastOccur + 1);
                }
            }
        }

        // Return the final result
        return result;
    }

    public static void main(String[] args)
    {
        // Define an input string
        String s = "abbca";

        // Call the function and print the result
        System.out.println(fun(s));
    }
}

// This code is contributed by Taranpreet Singh.

def fun(s):
    # Get the length of the input string
    n = len(s)
    
    # Initialize the result to 0
    result = 0
    
    # Loop through each lowercase character
    for ch in range(ord('a'), ord('z') + 1):
        ch = chr(ch)
        
        # Initialize the last occurrence of the character to -1
        last_occur = -1
        
        # Loop through the input string
        for i in range(n):
            if s[i] == ch:
                # If the current character matches the current alphabet character,
                # add the position of the character (1-based index) to the result
                result += (i + 1)
                # Update the last occurrence position
                last_occur = i
            else:
                # If the current character doesn't match the current alphabet character,
                # add the position of the last occurrence (if any) to the result
                result += (last_occur + 1)
    
    # Return the final result
    return result

# Driver code
s = "abbca"
print(fun(s))
#Contributed by Aditi Tyagi

using System;

class Program
{
    // Function to calculate the answer for a given string
    static long Fun(string s)
    {
        // Get the length of the input string
        int n = s.Length;

        // Initialize the result to 0
        long result = 0;

        // Loop through each lowercase character
        for (char ch = 'a'; ch <= 'z'; ch++)
        {
            // Initialize the last occurrence of the character to -1
            int last_occur = -1;

            // Loop through the input string
            for (int i = 0; i < n; i++)
            {
                if (s[i] == ch)
                {
                    // If the current character matches the current alphabet character,
                    // add the position of the character (1-based index) to the result
                    result += (i + 1);

                    // Update the last occurrence position
                    last_occur = i;
                }
                else
                {
                    // If the current character doesn't match the current alphabet character,
                    // add the position of the last occurrence (if any) to the result
                    result += (last_occur + 1);
                }
            }
        }

        // Return the final result
        return result;
    }

    // Main method
    static void Main()
    {
        // Define an input string
        string s = "abbca";

        // Call the function and print the result
        Console.WriteLine(Fun(s));
    }
}

// Function to calculate the answer for a given string
function fun(s) {
    // Get the length of the input string
    const n = s.length;

    // Initialize the result to 0
    let result = 0;

    // Loop through each lowercase character
    for (let ch = 'a'; ch <= 'z'; ch = String.fromCharCode(ch.charCodeAt(0) + 1)) {
        // Initialize the last occurrence of the character to -1
        let lastOccur = -1;

        // Loop through the input string
        for (let i = 0; i < n; i++) {
            if (s[i] === ch) {
                // If the current character matches the current alphabet character,
                // add the position of the character (1-based index) to the result
                result += (i + 1);

                // Update the last occurrence position
                lastOccur = i;
            } else {
                // If the current character doesn't match the current alphabet character,
                // add the position of the last occurrence (if any) to the result
                result += (lastOccur + 1);
            }
        }
    }

    // Return the final result
    return result;
}

// Main method
function main() {
    // Define an input string
    const s = "abbca";

    // Call the function and print the result
    console.log(fun(s));
}

// Call the main method to start the program
main();

28

Time Complexity: O(26*N), where N is the length of the input string.
Auxiliary Space: O(1)