Algorithm Design Expert

🧮 Algorithm Design Analysis

Problem: Find Longest Palindromic Substring

📊 Solution Approaches Comparison

🎯 Optimal Implementation: Expand Around Centers

def longest_palindrome(s: str) -> str:
    """
    Find the longest palindromic substring using center expansion.
    
    Time Complexity: O(n²)
    Space Complexity: O(1)
    
    Args:
        s: Input string to search
        
    Returns:
        Longest palindromic substring
    """
    if not s:
        return ""
    
    start = 0
    max_len = 1
    
    def expand_around_center(left: int, right: int) -> int:
        """Expand around center and return length."""
        while (left >= 0 and right < len(s) and 
               s[left] == s[right]):
            left -= 1
            right += 1
        return right - left - 1
    
    for i in range(len(s)):
        # Check for odd-length palindromes (center at i)
        len1 = expand_around_center(i, i)
        
        # Check for even-length palindromes (center between i and i+1)
        len2 = expand_around_center(i, i + 1)
        
        # Update maximum if we found a longer palindrome
        current_max = max(len1, len2)
        if current_max > max_len:
            max_len = current_max
            start = i - (current_max - 1) // 2
    
    return s[start:start + max_len]

# Comprehensive Test Cases
def test_longest_palindrome():
    """Test cases covering edge cases and normal scenarios."""
    test_cases = [
        ("babad", "bab"),  # or "aba"
        ("cbbd", "bb"),
        ("a", "a"),
        ("ac", "a"),  # or "c"
        ("", ""),
        ("racecar", "racecar"),
        ("abcdef", "a"),  # no palindromes > 1
    ]
    
    for input_str, expected in test_cases:
        result = longest_palindrome(input_str)
        print(f"Input: {{input_str}} -> Output: {{result}}")
        assert len(result) == len(expected), f"Failed for {{input_str}}"

# Performance Analysis
import time

def benchmark():
    """Benchmark with different input sizes."""
    test_strings = [
        "a" * 100,
        "ab" * 500,
        "racecar" * 100
    ]
    
    for test_str in test_strings:
        start_time = time.time()
        result = longest_palindrome(test_str)
        end_time = time.time()
        
        print(f"Length {{len(test_str)}}: {{end_time - start_time:.4f}}s")

🔍 Complexity Analysis

• Time: O(n²) - for each center, we expand up to n characters
• Space: O(1) - only using constant extra space
• Best Case: O(n) when no palindromes exist
• Worst Case: O(n²) when entire string is palindromic