# Solving Leetcode Interviews in Seconds with AI: Smallest Subsequence of Distinct Characters


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1081" 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 lexicographically smallest subsequence of s that contains all the distinct characters of s exactly once.   Example 1:  Input: s = "bcabc" Output: "abc"  Example 2:  Input: s = "cbacdcbc" Output: "acdb"    Constraints:  1 <= s.length <= 1000 s consists of lowercase English letters.    Note: This question is the same as 316: https://leetcode.com/problems/remove-duplicate-letters/

	# Explanation
	Here's a breakdown of the approach, followed by the Python code:

*   **Greedy Approach:** Iterate through the string, maintaining a stack representing the potential subsequence. At each character, decide whether to add it to the stack or remove larger characters already in the stack to make space for a smaller character later.
*   **Last Occurrence Tracking:** Use a dictionary to store the last index of each character in the string. This allows us to check if a character already in the stack might be needed later.
*   **Visited Set:** Maintain a set of visited characters to ensure that each distinct character appears only once in the result.

*   **Time Complexity:** O(N), where N is the length of the string.
*   **Space Complexity:** O(1), as the stack and last occurrence map can have at most 26 elements (lowercase English letters).

	
	# Code
	```python
	def smallestSubsequence(s: str) -> str:
    """
    Finds the lexicographically smallest subsequence of s that contains all
    distinct characters of s exactly once.
    """

    last_occurrence = {}
    for i, char in enumerate(s):
        last_occurrence[char] = i

    stack = []
    visited = set()

    for i, char in enumerate(s):
        if char in visited:
            continue

        while stack and char < stack[-1] and i < last_occurrence[stack[-1]]:
            visited.remove(stack[-1])
            stack.pop()

        stack.append(char)
        visited.add(char)

    return "".join(stack)
	```