# [Code] Longest Palindromic Substring | Code explanation | Leetcode 5

Education

## Introduction

Welcome back to my channel! In today's video, we'll be diving into the code explanation for the **Longest Palindromic Substring** problem. If you haven't watched my previous video where I discussed the approach and did a dry run for this problem, I highly recommend checking that out first. You can find the link to that video in the description below.

In this article, I'll break down the coding approach to solving the problem effectively.

## Code Explanation

First, we initialize a variable called `start`

which will help us track where our longest palindromic substring starts. We'll also maintain a variable for the maximum length of the palindrome found. At the end of the algorithm, we'll return the substring from the original string based on the starting index and the calculated length.

The coding logic in Java or C can be structured as follows:

**Initialize Variables**:`start`

: Holds the starting index of the longest palindromic substring.`maxLength`

: Holds the maximum length of the found palindromic substring.

**Loop Through the String**:- Start from index 1 (or 0, depending on the implementation).
- For even-length palindromes, initially set left (
`l`

) to`i - 1`

and right (`r`

) to`i`

.

`// Even case l = i - 1; r = i;`

- For odd-length palindromes, set left to
`i - 1`

and right to`i + 1`

.

`// Odd case l = i; r = i + 1;`

**Check for Palindrome**:- In both cases, while the characters at the positions
`l`

and`r`

are the same (i.e.,`S[l] == S[r]`

), continue to check. - Calculate the length of the substring and update
`maxLength`

and`start`

if a longer palindrome is found.

- In both cases, while the characters at the positions
**Return the Result**:- Finally, return the substring using the
`start`

index and`start + maxLength`

as the end index.

- Finally, return the substring using the

This approach ensures that we're able to find the longest palindromic substring efficiently. The time complexity of the solution is O(n^2) in the worst case due to the nesting of loops, but the space complexity remains O(1) since no extra data structures are employed.

I hope this breakdown clarifies the problem-solving approach. Thank you for watching, and don't forget to subscribe to my channel!

## Keywords

- Longest Palindromic Substring
- Palindrome
- Start Index
- Max Length
- O(n^2) Time Complexity
- O(1) Space Complexity
- Coding Approach

## FAQ

**Q: What is the Longest Palindromic Substring problem?**

A: It's a problem that involves finding the longest substring in a given string that reads the same forwards and backwards (a palindrome).

**Q: What are the time and space complexities of the solution?**

A: The time complexity of the solution is O(n^2) in the worst case, while the space complexity is O(1) since no additional data structures are used.

**Q: How does the code differentiate between odd and even-length palindromes?**

A: The code uses two pointers (left and right) starting at different indices based on whether the center of the palindrome is at the character or between two characters.

**Q: Where can I find the previous video on the approach to this problem?**

A: You can find the link to the previous video in the description of this video.