Merge pull request Dijkstra-Edu#94 from AmanDeol7/aman/sol-2

Solution Dijkstra-Edu#5 - Aman Deol - 02/09/2025

Author: JRS296

DP/#5 - Longest Palindromic Substring - Medium/Explanation.md

@@ -0,0 +1,126 @@
+# Longest Palindromic Substring
+
+**Difficulty:** Medium  
+**Category:** String, Dynamic Programming, Expand Around Center  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/longest-palindromic-substring/)  
+
+---
+
+## 📝 Introduction
+
+We are given a string `s` and need to return the **longest palindromic substring** in `s`.  
+
+A palindrome is a string that reads the same forward and backward (e.g., `"aba"`, `"abba"`).  
+We want the **longest substring** (continuous segment) that satisfies this property.  
+
+---
+
+## 💡 Approach & Key Insights
+
+1. **Brute Force**  
+   - Generate all substrings and check if each is a palindrome.  
+   - Too slow: O(n³) (substring generation + palindrome check).  
+
+2. **Expand Around Center (Optimal for interview)**  
+   - A palindrome mirrors around its center.  
+   - For each index in `s`, try to expand outwards for:
+     - Odd length palindrome (center at one character).  
+     - Even length palindrome (center between two characters).  
+   - Keep track of the longest one.  
+   - Time: O(n²), Space: O(1).  
+
+3. **Dynamic Programming**  
+   - Use a DP table where `dp[i][j] = true` if substring `s[i..j]` is a palindrome.  
+   - Build up from length 1 → n.  
+   - Time: O(n²), Space: O(n²).  
+
+4. **Manacher’s Algorithm (Advanced)**  
+   - Linear time O(n). Rarely required in interviews.  
+   - Uses transformed string with separators (`#`) to handle even/odd uniformly.  
+
+👉 For coding interviews, **Expand Around Center** is the most elegant and accepted solution.  
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Expand Around Center
+
+- For each index `i` in `s`, expand outward to find:
+  - Longest odd palindrome centered at `i`.  
+  - Longest even palindrome centered between `i` and `i+1`.  
+- Track the maximum length found.  
+
+**Time Complexity:** O(n²)  
+**Space Complexity:** O(1)  
+
+---
+
+### 2️⃣ Dynamic Programming
+
+- Fill a DP table `dp[i][j]`.  
+- Base cases:
+  - Single characters are palindromes.  
+  - Two equal characters form a palindrome of length 2.  
+- For longer substrings, use relation:  
+  ```
+  dp[i][j] = (s[i] == s[j]) && dp[i+1][j-1]
+  ```  
+- Track longest palindrome.  
+
+**Time Complexity:** O(n²)  
+**Space Complexity:** O(n²)  
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach              | Time Complexity | Space Complexity |
+| --------------------- | --------------- | ---------------- |
+| Brute Force           | O(n³)           | O(1)             |
+| Expand Around Center  | O(n²)           | O(1)             |
+| Dynamic Programming   | O(n²)           | O(n²)            |
+| Manacher’s Algorithm  | O(n)            | O(n)             |
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+Example 1:
+```
+Input: s = "babad"
+
+Centers:
+- Expand at 'b' → "bab"
+- Expand at 'a' → "aba"
+Longest found = "bab" (or "aba")
+
+Output: "bab"
+```
+
+Example 2:
+```
+Input: s = "cbbd"
+
+Centers:
+- Expand at 'c' → "c"
+- Expand between "bb" → "bb"
+Longest = "bb"
+
+Output: "bb"
+```
+
+---
+
+
+## 🔗 Additional Resources
+
+- [Palindrome Explanation (Wikipedia)](https://en.wikipedia.org/wiki/Palindrome)  
+- [Manacher’s Algorithm Explanation](https://cp-algorithms.com/string/manacher.html)  
+- [Leetcode Discuss - Longest Palindromic Substring Solutions](https://leetcode.com/problems/longest-palindromic-substring/discuss/)  
+- [Youtube Video Explanation](https://www.youtube.com/watch?v=UflHuQj6MVA)  
+
+---
+
+Author: Aman Deol
+Date: 02/09/2025  

DP/#5 - Longest Palindromic Substring - Medium/Solution.cpp

@@ -0,0 +1,66 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// Approach 1: Brute Force
+class SolutionBruteForce {
+public:
+    string longestPalindrome(string s) {
+        string res = "";
+        int n = s.size();
+        for (int i = 0; i < n; i++) {
+            for (int j = i; j < n; j++) {
+                string sub = s.substr(i, j - i + 1);
+                string rev = sub;
+                reverse(rev.begin(), rev.end());
+                if (sub == rev && sub.size() > res.size()) {
+                    res = sub;
+                }
+            }
+        }
+        return res;
+    }
+};
+
+// Approach 2: Expand Around Center
+class SolutionExpand {
+public:
+    string expand(string& s, int l, int r) {
+        while (l >= 0 && r < s.size() && s[l] == s[r]) {
+            l--; r++;
+        }
+        return s.substr(l+1, r-l-1);
+    }
+
+    string longestPalindrome(string s) {
+        string res = "";
+        for (int i = 0; i < s.size(); i++) {
+            string odd = expand(s, i, i);
+            if (odd.size() > res.size()) res = odd;
+            string even = expand(s, i, i+1);
+            if (even.size() > res.size()) res = even;
+        }
+        return res;
+    }
+};
+
+// Approach 3: Dynamic Programming
+class SolutionDP {
+public:
+    string longestPalindrome(string s) {
+        int n = s.size();
+        vector<vector<bool>> dp(n, vector<bool>(n, false));
+        string res = "";
+        
+        for (int i = n-1; i >= 0; i--) {
+            for (int j = i; j < n; j++) {
+                if (s[i] == s[j] && (j - i < 3 || dp[i+1][j-1])) {
+                    dp[i][j] = true;
+                }
+                if (dp[i][j] && (j - i + 1) > res.size()) {
+                    res = s.substr(i, j - i + 1);
+                }
+            }
+        }
+        return res;
+    }
+};

DP/#5 - Longest Palindromic Substring - Medium/Solution.java

@@ -0,0 +1,66 @@
+// Approach 1: Brute Force
+class SolutionBruteForce {
+    private boolean isPalindrome(String str) {
+        int l = 0, r = str.length() - 1;
+        while (l < r) {
+            if (str.charAt(l++) != str.charAt(r--)) return false;
+        }
+        return true;
+    }
+
+    public String longestPalindrome(String s) {
+        String res = "";
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            for (int j = i; j < n; j++) {
+                String sub = s.substring(i, j + 1);
+                if (isPalindrome(sub) && sub.length() > res.length()) {
+                    res = sub;
+                }
+            }
+        }
+        return res;
+    }
+}
+
+// Approach 2: Expand Around Center
+class SolutionExpand {
+    private String expand(String s, int l, int r) {
+        while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) {
+            l--; r++;
+        }
+        return s.substring(l+1, r);
+    }
+
+    public String longestPalindrome(String s) {
+        String res = "";
+        for (int i = 0; i < s.length(); i++) {
+            String odd = expand(s, i, i);
+            if (odd.length() > res.length()) res = odd;
+            String even = expand(s, i, i+1);
+            if (even.length() > res.length()) res = even;
+        }
+        return res;
+    }
+}
+
+// Approach 3: Dynamic Programming
+class SolutionDP {
+    public String longestPalindrome(String s) {
+        int n = s.length();
+        boolean[][] dp = new boolean[n][n];
+        String res = "";
+        
+        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 (dp[i][j] && (j - i + 1) > res.length()) {
+                    res = s.substring(i, j+1);
+                }
+            }
+        }
+        return res;
+    }
+}

DP/#5 - Longest Palindromic Substring - Medium/Solution.py

@@ -0,0 +1,46 @@
+# Approach 1: Brute Force
+class SolutionBruteForce:
+    def longestPalindrome(self, s: str) -> str:
+        def is_palindrome(sub):
+            return sub == sub[::-1]
+        res = ""
+        n = len(s)
+        for i in range(n):
+            for j in range(i, n):
+                if is_palindrome(s[i:j+1]) and len(s[i:j+1]) > len(res):
+                    res = s[i:j+1]
+        return res
+
+
+# Approach 2: Expand Around Center
+class SolutionExpand:
+    def longestPalindrome(self, s: str) -> str:
+        def expand(l, r):
+            while l >= 0 and r < len(s) and s[l] == s[r]:
+                l -= 1
+                r += 1
+            return s[l+1:r]
+        
+        res = ""
+        for i in range(len(s)):
+            odd = expand(i, i)
+            if len(odd) > len(res): res = odd
+            even = expand(i, i+1)
+            if len(even) > len(res): res = even
+        return res
+
+
+# Approach 3: Dynamic Programming
+class SolutionDP:
+    def longestPalindrome(self, s: str) -> str:
+        n = len(s)
+        dp = [[False] * n for _ in range(n)]
+        res = ""
+        
+        for i in range(n-1, -1, -1):
+            for j in range(i, n):
+                if s[i] == s[j] and (j - i < 3 or dp[i+1][j-1]):
+                    dp[i][j] = True
+                if dp[i][j] and (j - i + 1) > len(res):
+                    res = s[i:j+1]
+        return res