Palindrome Partitioning Using Backtracking in DSA Javascript - Time & Space Complexity

Time Complexity: Palindrome Partitioning Using Backtracking

O(n * 2^n)

Understanding Time Complexity

We want to understand how the time needed grows when we find all palindrome partitions of a string using backtracking.

How does the number of steps change as the string gets longer?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function isPalindrome(s, start, end) {
  while (start < end) {
    if (s[start] !== s[end]) return false;
    start++;
    end--;
  }
  return true;
}

function backtrack(s, start, path, result) {
  if (start === s.length) {
    result.push([...path]);
    return;
  }
  for (let end = start; end < s.length; end++) {
    if (isPalindrome(s, start, end)) {
      path.push(s.substring(start, end + 1));
      backtrack(s, end + 1, path, result);
      path.pop();
    }
  }
}

function partition(s) {
  const result = [];
  backtrack(s, 0, [], result);
  return result;
}
    

This code finds all ways to split a string into parts where each part is a palindrome, using backtracking.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The recursive backtracking explores all substring partitions, checking palindromes repeatedly.
• How many times: For each position, it tries all possible substring ends, and for each substring, it checks palindrome by scanning characters.

How Execution Grows With Input

As the string length grows, the number of palindrome partitions grows very fast, and palindrome checks happen many times.

Input Size (n)	Approx. Operations
10	Thousands of palindrome checks and recursive calls
100	Millions to billions of operations due to many partitions
1000	Operations explode exponentially, not practical without optimization

Pattern observation: The work grows exponentially because every substring can lead to multiple recursive paths.

Final Time Complexity

Time Complexity: O(n * 2^n)

This means the time grows roughly like two to the power of the string length times the length itself, because we explore many partitions and check palindromes.

Common Mistake

[X] Wrong: "The time complexity is just O(n^2) because we only check substrings."

[OK] Correct: The number of possible partitions grows exponentially, so the recursive calls multiply quickly beyond just substring checks.

Interview Connect

Understanding this complexity helps you explain why backtracking can be slow and when to expect exponential time, a key skill for problem solving.

Self-Check

"What if we cached palindrome checks to avoid repeated work? How would the time complexity change?"

Practice

1. What is the main goal of palindrome partitioning using backtracking?

easy

A. To split a string into all possible palindrome substrings

B. To find the longest palindrome substring in a string

C. To reverse a string using recursion

D. To count the number of palindromes in a string

Solution

1. Step 1: Understand palindrome partitioning

   Palindrome partitioning means dividing a string into parts where each part is a palindrome.

2. Step 2: Role of backtracking

   Backtracking helps explore all possible ways to split the string and keep only palindrome parts.

3. Final Answer:

   To split a string into all possible palindrome substrings -> Option A

4. Quick Check:

   Palindrome partitioning = splitting into palindrome substrings [OK]

Hint: Backtracking tries all splits keeping palindromes only [OK]

Common Mistakes:

• Confusing palindrome partitioning with longest palindrome substring
• Thinking it only finds one palindrome partition
• Assuming it reverses the string

2. Which of the following is the correct way to check if a substring s.slice(start, end) is a palindrome in JavaScript?

easy

A. Check if s.slice(start, end) === s.slice(end, start).reverse()

B. Check if s.slice(start, end) === s.slice(start, end).split('').reverse().join('')

C. Check if s.slice(start, end) === s.reverse()

D. Check if s.slice(start, end) === s.split('').reverse()

Solution

1. Step 1: Extract substring correctly

   Use s.slice(start, end) to get substring from start to end-1.

2. Step 2: Check palindrome by reversing substring

   Reverse substring by splitting to array, reversing, then joining back to string.

3. Final Answer:

   Check if s.slice(start, end) === s.slice(start, end).split('').reverse().join('') -> Option B

4. Quick Check:

   Reverse substring and compare equals original [OK]

Hint: Reverse substring with split, reverse, join to check palindrome [OK]

Common Mistakes:

• Using slice with reversed indices (end before start)
• Trying to reverse string directly without split
• Comparing substring to reversed full string

3. What will be the output of the following code snippet?

function isPalindrome(s) {
  return s === s.split('').reverse().join('');
}

function backtrack(s, start, path, result) {
  if (start === s.length) {
    result.push([...path]);
    return;
  }
  for (let end = start + 1; end <= s.length; end++) {
    let sub = s.slice(start, end);
    if (isPalindrome(sub)) {
      path.push(sub);
      backtrack(s, end, path, result);
      path.pop();
    }
  }
}

let result = [];
backtrack('aab', 0, [], result);
console.log(result);

medium

A. [["a", "a", "b"], ["aa", "b"]]

B. [["aab"]]

C. [["a", "ab"]]

D. [["aa", "ab"]]

Solution

1. Step 1: Check palindrome substrings in 'aab'

   Substrings: 'a', 'aa', 'aab', 'ab', 'b'. Palindromes are 'a', 'aa', 'b'.

2. Step 2: Backtracking builds partitions

   Partitions: ['a','a','b'] and ['aa','b'] are valid palindrome partitions.

3. Final Answer:

   [["a", "a", "b"], ["aa", "b"]] -> Option A

4. Quick Check:

   All palindrome partitions of 'aab' = [['a','a','b'], ['aa','b']] [OK]

Hint: Check all palindrome splits recursively to get partitions [OK]

Common Mistakes:

• Including non-palindrome substrings like 'ab'
• Missing the partition ['aa','b']
• Confusing output format with strings instead of arrays

4. Identify the bug in this backtracking code for palindrome partitioning:

function backtrack(s, start, path, result) {
  if (start > s.length) {
    result.push(path);
    return;
  }
  for (let end = start + 1; end <= s.length; end++) {
    let sub = s.slice(start, end);
    if (sub === sub.split('').reverse().join('')) {
      path.push(sub);
      backtrack(s, end, path, result);
      path.pop();
    }
  }
}

medium

A. The path array should not be mutated with push and pop

B. The substring check is incorrect; should use a separate isPalindrome function

C. The base case condition should be start === s.length, not start > s.length

D. The for loop should start from end = start, not start + 1

Solution

1. Step 1: Analyze base case condition

   Base case triggers when start > s.length, but valid partitions end exactly at start === s.length.

2. Step 2: Correct base case to push result

   Change condition to start === s.length to add current path to result correctly.

3. Final Answer:

   The base case condition should be start === s.length, not start > s.length -> Option C

4. Quick Check:

   Base case triggers at string end index [OK]

Hint: Base case must match string length exactly to save partitions [OK]

Common Mistakes:

• Using > instead of === for base case
• Not pushing a copy of path (but not asked here)
• Starting loop incorrectly at start instead of start+1

5. Given the string "racecar", how many palindrome partitions will the backtracking algorithm find?

hard

A. 8

B. 6

C. 4

D. 10

Solution

1. Step 1: Identify palindrome substrings in 'racecar'

   Palindromes include all single characters 'r','a','c','e','c','a','r'; 'cec' (indices 2-4); 'aceca' (1-5); 'racecar' (whole).

2. Step 2: Count all palindrome partitions

   Valid partitions: ['racecar'], ['r','aceca','r'], ['r','a','cec','a','r'], ['r','a','c','e','c','a','r'], and others. Total 10.

3. Final Answer:

   10 -> Option D

4. Quick Check:

   Backtracking finds 10 palindrome partitions for 'racecar' [OK]

Hint: Count all palindrome splits including nested palindromes [OK]

Common Mistakes:

• Counting only single-character partitions
• Missing larger palindrome substrings like 'aceca'
• Assuming only 1 or 2 partitions exist