# Solving Leetcode Interviews in Seconds with AI: Select K Disjoint Special Substrings


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3458" 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 of length n and an integer k, determine whether it is possible to select k disjoint special substrings. A special substring is a substring where:  Any character present inside the substring should not appear outside it in the string. The substring is not the entire string s.  Note that all k substrings must be disjoint, meaning they cannot overlap. Return true if it is possible to select k such disjoint special substrings; otherwise, return false.   Example 1:  Input: s = "abcdbaefab", k = 2 Output: true Explanation:  We can select two disjoint special substrings: "cd" and "ef". "cd" contains the characters 'c' and 'd', which do not appear elsewhere in s. "ef" contains the characters 'e' and 'f', which do not appear elsewhere in s.   Example 2:  Input: s = "cdefdc", k = 3 Output: false Explanation: There can be at most 2 disjoint special substrings: "e" and "f". Since k = 3, the output is false.  Example 3:  Input: s = "abeabe", k = 0 Output: true    Constraints:  2 <= n == s.length <= 5 * 104 0 <= k <= 26 s consists only of lowercase English letters.  

	# Explanation
	Here's the approach to solve this problem:

*   **Identify Potential Substrings:** Iterate through the string, identifying potential "special" substrings. A substring is a candidate if all characters within it appear *only* within that substring.
*   **Greedy Selection:** Greedily select the disjoint special substrings from left to right. This ensures that we maximize the number of such substrings we can find.
*   **Count and Compare:** Count the number of disjoint special substrings found. If the count is greater than or equal to `k`, return `True`; otherwise, return `False`.

*   **Runtime Complexity:** O(n), where n is the length of the string.
*   **Storage Complexity:** O(1).

	
	# Code
	```python
	def solve():
    s = input()
    k = int(input())
    
    n = len(s)
    
    if k == 0:
        print(True)
        return

    count = 0
    i = 0
    while i < n:
        found = False
        for length in range(1, n - i + 1):
            sub = s[i:i+length]
            
            valid = True
            for char in set(sub):
                if s.count(char) != sub.count(char):
                    valid = False
                    break
            
            if valid and sub != s:
                count += 1
                i += length
                found = True
                break
        
        if not found:
            i += 1

    print(count >= k)

solve()
	```