Skip to content
QuizMaker logoQuizMaker
Activity
DSA Course: Interview Patterns and Problem Solving
Module 2: Strings
Best Time to Buy and Sell Stock: Greedy Pattern
Maximum Subarray: Kadane Pattern
Move Zeroes: Two pointers Pattern
Contains Duplicate: Set Pattern
Valid Anagram: Frequency map Pattern
Longest Substring Without Repeating Characters: Sliding window Pattern
Valid Palindrome: Two pointers Pattern
Longest Palindromic Substring: Expand around center Pattern
Group Anagrams: Hash key Pattern
Binary Search: Classic search Pattern
Search Insert Position: Lower bound Pattern
First Bad Version: Predicate search Pattern
Search in Rotated Sorted Array: Rotated search Pattern
Find Minimum in Rotated Sorted Array: Rotated minimum Pattern
Valid Parentheses: Stack matching Pattern
Min Stack: Auxiliary stack Pattern
Daily Temperatures: Monotonic stack Pattern
Next Greater Element I: Monotonic stack Pattern
Evaluate Reverse Polish Notation: Stack evaluation Pattern
Reverse Linked List: Pointer reversal Pattern
Merge Two Sorted Lists: Dummy node Pattern
Linked List Cycle: Fast and slow pointers Pattern
Middle of the Linked List: Fast and slow pointers Pattern
Remove Nth Node From End: Two pointers Pattern
Binary Tree Traversals: DFS recursion Pattern
Maximum Depth of Binary Tree: Height recursion Pattern
Binary Tree Level Order Traversal: BFS queue Pattern
Validate Binary Search Tree: Range bounds Pattern
Lowest Common Ancestor: Recursive split Pattern
Connected Components: Adjacency DFS Pattern
Number of Islands: Grid DFS Pattern
Flood Fill: Boundary DFS Pattern
Clone Graph: Hash Map DFS Pattern
Course Schedule: Topological Sort Pattern
Union Find Components: Disjoint Set Pattern
Shortest Path in Unweighted Graph: BFS Distance Pattern
Climbing Stairs: Fibonacci DP Pattern
House Robber: Pick or Skip DP Pattern
Coin Change: Minimum Coins DP Pattern
Longest Increasing Subsequence: Binary Search DP Pattern
Longest Common Subsequence: 2D DP Pattern
0/1 Knapsack: Capacity DP Pattern
Longest Consecutive Sequence: Hash Set Pattern
Subarray Sum Equals K: Prefix Sum Hashmap Pattern
First Unique Character: Frequency Map Pattern
Find Duplicates: Frequency Map Pattern
Ransom Note: Character Availability Pattern
Sort Colors: Dutch National Flag Pattern
Next Permutation: Pivot and Suffix Reversal Pattern
Merge Intervals: Sort and Sweep Pattern
Find First and Last Position: Boundary Binary Search Pattern
Search a 2D Matrix: Flattened Binary Search Pattern
Subsets: Pick or Skip Recursion Pattern
Generate Parentheses: Valid State Backtracking Pattern
Combination Sum: Reuse Choice Backtracking Pattern
N-Queens: Constraint Backtracking Pattern
Word Search: Grid Backtracking Pattern
Kth Largest Element: Size-K Min-Heap Pattern
Top K Frequent Elements: Frequency Heap Pattern
Merge K Sorted Lists: Min-Heap Multiway Merge Pattern
Median Finder: Two Heaps Pattern
Task Scheduler: Greedy Max-Heap Pattern
Jump Game: Farthest Reach Greedy Pattern
Gas Station: Greedy Reset Pattern
Non-overlapping Intervals: Earliest End Greedy Pattern
Minimum Arrows to Burst Balloons: Interval End Greedy Pattern
Partition Labels: Last Occurrence Greedy Pattern
Single Number: XOR Cancellation Pattern
Power of Two: n and n-1 Pattern
Number of 1 Bits: Brian Kernighan Pattern
Single Number III: Rightmost Set Bit Pattern
XOR From 1 to N: Modulo Cycle Pattern
Prime Check: Square Root Trial Division Pattern
Sieve of Eratosthenes: Prime Marking Pattern
GCD: Euclidean Remainder Pattern
Binary Exponentiation: Fast Power Pattern
Modular Inverse: Extended Euclid Pattern
Implement Trie: Prefix Tree Pattern
Longest Common Prefix: Single Branch Trie Pattern
LRU Cache: Hash Map Plus Recency List Pattern
Segment Tree: Range Sum Query Pattern
Fenwick Tree: Binary Indexed Prefix Sum Pattern
CONTENTS

Longest Palindromic Substring: Expand around center Pattern

Expand from each possible center to find the longest contiguous palindrome.

DSA Course: Interview Patterns and Problem Solving
Module 2: Strings
dsa
data structures and algorithms
+4
May 28, 2026
27
A

Learning Outcome

After this lesson, you should be able to use the symmetry of palindromes and expand from centers instead of generating every substring.

Problem Statement

Given a string s, return the longest palindromic substring in s. The substring must be contiguous.

InputOutputWhy
"babad""bab" or "aba"Both are valid longest palindromic substrings.
"cbbd""bb"The even-length center is between the two b characters.

Brute Force Approach

Generate every substring and check whether it is a palindrome. Keep the longest valid one.

This is very direct, but checking many substrings and validating each one can reach O(n^3).

Optimized Approach

Every palindrome has a center. For each index, expand once for odd-length palindromes and once for even-length palindromes. Track the best range found.

Exact Pseudocode

bestStart = 0
bestLength = 1
expand(left, right):
  while left >= 0 and right < length(s) and s[left] == s[right]:
    update best range if right - left + 1 is larger
    left = left - 1
    right = right + 1
for center from 0 to length(s) - 1:
  expand(center, center)
  expand(center, center + 1)
return substring(bestStart, bestLength)

Reference Code

class Solution:
    def longestPalindrome(self, s):
        if not s:
            return ""

        best_start = 0
        best_len = 1

        def expand(left, right):
            nonlocal best_start, best_len
            while left >= 0 and right < len(s) and s[left] == s[right]:
                length = right - left + 1
                if length > best_len:
                    best_start = left
                    best_len = length
                left -= 1
                right += 1

        for center in range(len(s)):
            expand(center, center)
            expand(center, center + 1)

        return s[best_start:best_start + best_len]

Sample Dry Run

CenterExpansionBest
b at index 0bb
a at index 1babbab
b at index 2ababab or aba
Other centersNo longer palindromeLength 3 remains best

Complexity

MeasureValueReason
TimeO(n^2)There are O(n) centers and each expansion can scan outward.
SpaceO(1)Only best range variables are stored.

Edge Cases

  • Empty string if platform allows it.
  • Single-character string.
  • Even-length palindrome such as "bb".

Interview Checklist

  • Handle both odd and even centers.
  • Track indices, not only the substring.
  • Return any valid longest palindrome if multiple exist.

FAQs

Why expand around centers?

Because palindromes are symmetric, so a center fully determines how far the palindrome can grow.

Why check even centers?

Palindromes like "bb" have a center between two characters.

What is the core pattern?

Expand around center.

Share this article

Share on TwitterShare on LinkedInShare on FacebookShare on WhatsAppShare on Email

Test your knowledge

Take a quick quiz based on this chapter.

mediumDSA Course
Longest Palindromic Substring - Expand around center Pattern Practice Quiz
5 questions8 min

0 comments

Please login to comment.
No comments yet.
Lesson 4 of 5 in Module 2: Strings
Previous in Module 2: Strings
Valid Palindrome: Two pointers Pattern
Next in Module 2: Strings
Group Anagrams: Hash key Pattern
Back to DSA Course: Interview Patterns and Problem Solving
Back to moduleCategories