# Solving Leetcode Interviews in Seconds with AI: Split a String Into the Max Number of Unique Substrings


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1593" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given a string s, return the maximum number of unique substrings that the given string can be split into. You can split string s into any list of non-empty substrings, where the concatenation of the substrings forms the original string. However, you must split the substrings such that all of them are unique. A substring is a contiguous sequence of characters within a string.   Example 1:  Input: s = "ababccc" Output: 5 Explanation: One way to split maximally is ['a', 'b', 'ab', 'c', 'cc']. Splitting like ['a', 'b', 'a', 'b', 'c', 'cc'] is not valid as you have 'a' and 'b' multiple times.  Example 2:  Input: s = "aba" Output: 2 Explanation: One way to split maximally is ['a', 'ba'].  Example 3:  Input: s = "aa" Output: 1 Explanation: It is impossible to split the string any further.    Constraints:   1 <= s.length <= 16   s contains only lower case English letters.   

	# Explanation
	Here's the breakdown of the solution:

*   **Greedy Backtracking:** The approach uses a greedy, depth-first search (backtracking) strategy. It iteratively tries to create unique substrings from the beginning of the string.
*   **Set for Uniqueness:** A set is used to keep track of the substrings that have already been used in the current split. This ensures that only unique substrings are considered.
*   **Maximizing Count:** The backtracking explores all possible splits, keeping track of the maximum number of unique substrings found so far.

*   **Runtime Complexity:** O(2<sup>n</sup>), where n is the length of the string.
*   **Storage Complexity:** O(n), where n is the length of the string (due to the recursion depth and the set size).

	
	# Code
	```python
	def max_unique_split(s: str) -> int:
    """
    Given a string s, return the maximum number of unique substrings that the
    given string can be split into.

    You can split string s into any list of non-empty substrings, where the
    concatenation of the substrings forms the original string. However, you must
    split the substrings such that all of them are unique.

    Args:
        s: The input string.

    Returns:
        The maximum number of unique substrings.
    """

    def backtrack(start: int, current_split: set[str]) -> int:
        """
        Recursive helper function to explore possible splits.

        Args:
            start: The starting index of the current substring.
            current_split: A set containing the unique substrings in the current split.

        Returns:
            The maximum number of unique substrings found in this branch.
        """

        if start == len(s):
            return len(current_split)

        max_splits = 0
        for i in range(start, len(s)):
            substring = s[start : i + 1]
            if substring not in current_split:
                current_split.add(substring)
                max_splits = max(max_splits, backtrack(i + 1, current_split))
                current_split.remove(substring)  # Backtrack

        return max_splits

    return backtrack(0, set())
	```