Algorithm Day94 - Longest Palindromic Substring

Posted on In , Views:

🧩 Problem Description

Given a string s, return the longest palindromic substring in s.

A palindrome is a string that reads the same backward as forward.

💬 Examples

Example 1

1
2
3
Input: s = "babad"
Output: "bab"
Explanation: "aba" is also a valid answer.

Example 2

1
2
Input: s = "cbbd"
Output: "bb"

💡 Intuition

We can solve this using Dynamic Programming or Expand Around Center.

🔹 Approach 1 — Expand Around Center

Every palindrome mirrors around its center.
There can be 2n - 1 centers (between characters and at characters).

Expand from each center until it’s no longer a palindrome.

🔢 Java Code (Expand Around Center)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 1) return "";
        int start = 0, end = 0;
        for (int i = 0; i < s.length(); i++) {
            int len1 = expandFromCenter(s, i, i);     // odd-length
            int len2 = expandFromCenter(s, i, i + 1); // even-length
            int len = Math.max(len1, len2);
            if (len > end - start) {
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }
        return s.substring(start, end + 1);
    }

    private int expandFromCenter(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }
        return right - left - 1;
    }
}

🔹 Approach 2 — Dynamic Programming

Let dp[i][j] mean whether substring s[i..j] is a palindrome.
Transition rule:

1
dp[i][j] = (s[i] == s[j]) && (j - i < 3 || dp[i + 1][j - 1])

🔢 Java Code (Dynamic Programming)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Solution {
    public String longestPalindrome(String s) {
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        int start = 0, maxLen = 1;
        
        for (int i = n - 1; i >= 0; i--) {
            for (int j = i; j < n; j++) {
                if (s.charAt(i) == s.charAt(j) && (j - i < 3 || dp[i + 1][j - 1])) {
                    dp[i][j] = true;
                    if (j - i + 1 > maxLen) {
                        maxLen = j - i + 1;
                        start = i;
                    }
                }
            }
        }
        return s.substring(start, start + maxLen);
    }
}

⏱ Complexity Analysis

Approach Time Complexity Space Complexity
Expand Around Center O(n²) O(1)
Dynamic Programming O(n²) O(n²)

✍️ Summary

  • Expand around every center or use DP.
  • Palindrome means symmetry around a center.
  • Expand method is simpler and more space-efficient.

Related problems:

  • lc-516 (Longest Palindromic Subsequence)
  • lc-647 (Palindromic Substrings)