Related Articles

# Split a string into maximum number of unique substrings

• Difficulty Level : Medium
• Last Updated : 18 Jul, 2021

Given string str, the task is to split the string into the maximum number of unique substrings possible and print their count.

Examples:

Input: str = “ababccc”
Output: 5
Explanation:
Split the given string into the substrings “a”, “b”, “ab”, “c” and “cc”.
Therefore, the maximum count of unique substrings is 5.

Input: str = “aba”
Output: 2

Approach: The problem can be solved by the Greedy approach. Follow the steps below to solve the problem:

1. Initialize a Set S.
2. Iterate over the characters of the string str and for each i and find the substring up to that index.
3. If the given substring is not present in the Set S, insert it updates the maximum count, and remove it from the Set, because the same character cannot be reused.
4. Return the maximum count.

Below is the implementation of the above approach:

## C++

 `// CPP program for the above approach``#include``using` `namespace` `std;` `// Utility function to find maximum count of``// unique substrings by splitting the string``int` `maxUnique(string S, set st)``{` `  ``// Stores maximum count of unique substring``  ``// by splitting the string into substrings``  ``int` `mx = 0;` `  ``// Iterate over the characters of the string``  ``for` `(``int` `i = 1; i <= S.length(); i++)``  ``{` `    ``// Stores prefix substring``    ``string tmp = S.substr(0, i);` `    ``// Check if the current substring``    ``// already exists``    ``if` `(st.find(tmp) == st.end())``    ``{` `      ``// Insert tmp into set``      ``st.insert(tmp);` `      ``// Recursively call for remaining``      ``// characters of string``      ``mx = max(mx, maxUnique(S.substr(i), st) + 1);` `      ``// Remove from the set``      ``st.erase(tmp);``    ``}``  ``}` `  ``// Return answer``  ``return` `mx;``}`  `// Function to find the maximum count of``// unique substrings by splitting a string``// into maximum number of unique substrings``int` `maxUniqueSplit(string S)``{``  ``set st;``  ``return` `maxUnique(S, st);``}` `// Driver Code``int` `main()``{``  ``string S = ``"ababccc"``;``  ``int` `res = maxUniqueSplit(S);` `  ``cout<

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;``class` `Solution {` `    ``// Function to find the maximum count of``    ``// unique substrings by splitting a string``    ``// into maximum number of unique substrings``    ``public` `int` `maxUniqueSplit(String S)``    ``{``        ``return` `maxUnique(S, ``new` `HashSet());``    ``}` `    ``// Utility function to find maximum count of``    ``// unique substrings by splitting the string``    ``public` `int` `maxUnique(String S, Set set)``    ``{` `        ``// Stores maximum count of unique substring``        ``// by splitting the string into substrings``        ``int` `max = ``0``;` `        ``// Iterate over the characters of the string``        ``for` `(``int` `i = ``1``; i <= S.length(); i++) {` `            ``// Stores prefix substring``            ``String tmp = S.substring(``0``, i);` `            ``// Check if the current substring``            ``// already exists``            ``if` `(!set.contains(tmp)) {` `                ``// Insert tmp into set``                ``set.add(tmp);` `                ``// Recursively call for remaining``                ``// characters of string``                ``max = Math.max(max, maxUnique(``                                        ``S.substring(i), set)``                                        ``+ ``1``);` `                ``// Remove from the set``                ``set.remove(tmp);``            ``}``        ``}` `        ``// Return answer``        ``return` `max;``    ``}``}` `// Driver Code``class` `GFG {` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``Solution st = ``new` `Solution();``        ``String S = ``"ababccc"``;``        ``int` `res = st.maxUniqueSplit(S);` `        ``System.out.println(res);``    ``}``}`

## Python3

 `# Python3 program for the above approach` `# Utility function to find maximum count of``# unique substrings by splitting the string``def` `maxUnique(S):``    ``global` `d` `    ``# Stores maximum count of unique substring``    ``# by splitting the string into substrings``    ``maxm ``=` `0` `    ``# Iterate over the characters of the string``    ``for` `i ``in` `range``(``1``, ``len``(S) ``+` `1``):` `        ``# Stores prefix substring``        ``tmp ``=` `S[``0``:i]` `        ``# Check if the current substring``        ``# already exists``        ``if` `(tmp ``not` `in` `d):` `            ``# Insert tmp into set``            ``d[tmp] ``=` `1` `            ``# Recursively call for remaining``            ``# characters of string``            ``maxm ``=` `max``(maxm, maxUnique(S[i:]) ``+` `1``)` `            ``# Remove from the set``            ``del` `d[tmp]` `    ``# Return answer``    ``return` `maxm` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Solution st = new Solution()``    ``S ``=` `"ababccc"``    ``d ``=` `{}``    ``res ``=` `maxUnique(S)``    ``# d = {}` `    ``print``(res)` `# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG {` `  ``// Function to find the maximum count of``  ``// unique substrings by splitting a string``  ``// into maximum number of unique substrings``  ``public` `int` `maxUniqueSplit(String S)``  ``{``    ``return` `maxUnique(S, ``new` `HashSet());``  ``}` `  ``// Utility function to find maximum count of``  ``// unique substrings by splitting the string``  ``public` `int` `maxUnique(String S, HashSet ``set``)``  ``{` `    ``// Stores maximum count of unique substring``    ``// by splitting the string into substrings``    ``int` `max = 0;` `    ``// Iterate over the characters of the string``    ``for` `(``int` `i = 1; i <= S.Length; i++) {` `      ``// Stores prefix substring``      ``String tmp = S.Substring(0, i);` `      ``// Check if the current substring``      ``// already exists``      ``if` `(!``set``.Contains(tmp)) {` `        ``// Insert tmp into set``        ``set``.Add(tmp);` `        ``// Recursively call for remaining``        ``// characters of string``        ``max = Math.Max(max, maxUnique(``          ``S.Substring(i), ``set``)``                       ``+ 1);` `        ``// Remove from the set``        ``set``.Remove(tmp);``      ``}``    ``}` `    ``// Return answer``    ``return` `max;``  ``}``}` `// Driver Code``public` `class` `GFG {` `  ``public` `static` `void` `Main(String[] args)``  ``{``    ``Solution st = ``new` `Solution();``    ``String S = ``"ababccc"``;``    ``int` `res = st.maxUniqueSplit(S);` `    ``Console.WriteLine(res);``  ``}``}` `// This code contributed by shikhasingrajput`

## Javascript

 ``
Output:
`5`

Time Complexity: O( )

Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up