Enhance README with problem explanation and solution

Added a detailed explanation of the Longest Palindromic Substring problem solution in Java, including constraints and implementation steps.

Author: javadev

src/main/java/g0001_0100/s0005_longest_palindromic_substring/readme.md

@@ -21,4 +21,67 @@ Given a string `s`, return _the longest_ _palindromic_ **substring** in `s`.
 **Constraints:**
 
 *   `1 <= s.length <= 1000`
-*   `s` consist of only digits and English letters.
+*   `s` consist of only digits and English letters.
+
+To solve the Longest Palindromic Substring problem in Java using a `Solution` class, we'll follow these steps:
+
+1. Define a `Solution` class with a method named `longestPalindrome`.
+2. Initialize variables to keep track of the start and end indices of the longest palindromic substring found so far (`start` and `end`).
+3. Iterate through the string `s`:
+   - For each character in the string, expand around it to check if it forms a palindrome.
+   - Handle both odd-length and even-length palindromes separately.
+   - Update `start` and `end` indices if a longer palindrome is found.
+4. Return the substring from `start` to `end`.
+5. Handle edge cases where the input string is empty or has a length of 1.
+
+Here's the implementation:
+
+```java
+public class Solution {
+    
+    public String longestPalindrome(String s) {
+        if (s == null || s.length() < 1) return "";
+        int start = 0;
+        int end = 0;
+        
+        for (int i = 0; i < s.length(); i++) {
+            int len1 = expandAroundCenter(s, i, i);
+            int len2 = expandAroundCenter(s, i, i + 1);
+            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 expandAroundCenter(String s, int left, int right) {
+        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
+            left--;
+            right++;
+        }
+        return right - left - 1;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+
+        // Test cases
+        String s1 = "babad";
+        System.out.println("Example 1 Output: " + solution.longestPalindrome(s1));
+
+        String s2 = "cbbd";
+        System.out.println("Example 2 Output: " + solution.longestPalindrome(s2));
+
+        String s3 = "a";
+        System.out.println("Example 3 Output: " + solution.longestPalindrome(s3));
+
+        String s4 = "ac";
+        System.out.println("Example 4 Output: " + solution.longestPalindrome(s4));
+    }
+}
+```
+
+This implementation provides a solution to the Longest Palindromic Substring problem in Java.