Palindrome Partitioning

Problem

Given a string s, partition s such that every 

substring

 of the partition is a 

palindrome

. Return all possible palindrome partitioning of s.

Example 1:

Input: s = "aab"
Output: [["a","a","b"],["aa","b"]]

Example 2:

Input: s = "a"
Output: [["a"]]

Intuition

The problem involves partitioning a given string s such that every substring of the partition is a palindrome. The goal is to find all possible palindrome partitionings of the string. This can be solved using a depth-first search (DFS) approach.

Approach

DFS Function:

Implement a DFS function (dfs) that takes a parameter i, representing the current index in the string.
In the base case:
If i is greater than or equal to the length of the string, append a copy of the current partition (part) to the result (res).
Otherwise, iterate over all possible ending indices j starting from i:
If the substring from i to j is a palindrome (using the ispali function), add the substring to the current partition and recursively call the dfs function for the next index j + 1.
After the recursive call, backtrack by removing the last added substring from the partition.
Palindrome Check Function:

Implement a helper function (ispali) that checks whether a substring of the string s from index start to end is a palindrome.
The function should return True if the substring is a palindrome and False otherwise.
Initialization:

Call the dfs function with the initial index i set to 0.
Return Result:

Return the final result (res), which contains all possible palindrome partitionings of the string.

Complexity

• Time complexity:

The time complexity is O(N * 2^N), where N is the length of the string. This is because, in the worst case, there can be 2^N possible partitions, and checking whether each substring is a palindrome takes O(N) time.

• Space complexity:

The space complexity is O(N) due to the recursion stack and the space required for the result (res) and the current partition (part). The space for the recursion stack is proportional to the maximum depth of the recursion, which is N.

Code

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        res = []
        part = []

        def dfs(i):
            if i >= len(s):
                res.append(part.copy())
                return
            for j in range(i, len(s)):
                if self.ispali(s, i, j):
                    part.append(s[i:j + 1])
                    dfs(j + 1)
                    part.pop()

        dfs(0)
        return res

    def ispali(self, s, l, r):
        while l < r:
            if s[l] != s[r]:
                return False
            l, r = l + 1, r - 1
        
        return True