Find all Palindromic Partitions of a String

Given a string s, find all possible ways to partition it such that every substring in the partition is a palindrome.

Examples: 

Input: s = "geeks"
Output: [[g, e, e, k, s], [g, ee, k, s]]
Explanation: [g, e, e, k, s] and [g, ee, k, s] are the only partitions of "geeks" where each substring is a palindrome.

Input: s = "abcba"
Output: [[a, b, c, b, a], [a, bcb, a], [abcba]]
Explanation: [a, b, c, b, a], [a, bcb, a] and [abcba] are the only partitions of "abcba" where each substring is a palindrome.

[Approach 1] Using Recursion and Backtracking

The main idea is to use backtracking to explore all combinations of substrings starting from each index, including a substring in the current partition only if it is a palindrome.

Step-By-Step Approach:

• Start at index 0 of the string.
• Generate all substrings starting from the current index.
• Check if the current substring is a palindrome.
• If it is, add it to the current partition path.
• Recursively continue from the next index.
• If the end of the string is reached, add the current path to the result.
• Backtrack by removing the last added substring and try the next possibility.

g e e k s
g ee k s

Time Complexity: O(n × 2ⁿ), for exploring all possible partitions (2ⁿ) and checking each substring for palindrome in O(n) time.
Auxiliary Space: O(n × 2ⁿ), for storing all palindromic partitions and using recursion stack up to depth n.

[Approach 2] Using Bit Manipulation

The main idea is systematically explores all ways to cut a string into parts and checks which ones consist only of palindromic substrings. It uses binary representation to model cut/no-cut choices between characters

• If there n characters in the string, then there are n-1 positions to put a space or say cut the string.
• Each of these positions can be given a binary number 1 (If a cut is made in this position) or 0 (If no cut is made in this position).
• This will give a total of 2^n-1 partitions and for each partition check whether this partition is palindrome or not.

Illustration:

Input : geeks

0100 → ["ge","eks"] (not valid)
1011 → ["g","ee","k","s"] (valid)
1111 → ["g","e","e","k","s"] (valid)
0000 → ["geeks"] (not valid)

g e e k s 
g ee k s 

Time Complexity: O(n² × 2ⁿ) for generating all possible partitions (2ⁿ) and checking each partition for palindromes (up to O(n²) per partition).
Auxiliary Space: O(n × 2ⁿ), to store all palindromic partitions, each potentially having up to n substrings.

[Expected Approach] Backtracking with Memoization

The Idea is uses dynamic programming to precompute all substrings of the input string that are palindromes in O(n²) time. This precomputation helps in quickly checking whether a substring is a palindrome during the recursive backtracking phase. Then, it uses backtracking to explore all possible partitions of the string and collects only those partitions where every substring is a palindrome.

g e e k s 
g ee k s 

Time Complexity: O(n² + 2ⁿ×n), (n²) time for precomputing palindromic substrings and O(2ⁿ × n) for backtracking through all partitions.
Auxiliary Space: O(n²), for the DP table and O(n) for the recursion stack and temporary storage during backtracking.

A similar optimization can be applied to the bitmask-based approach by precomputing all palindromic substrings in O(n²) using dynamic programming. This reduces the palindrome-checking time per partition from O(n) to O(1), thereby improving the overall time complexity from O(n² × 2ⁿ) to O(n × 2ⁿ).