If we have the string "abc", we'll first assume that 'a' is the middle of a substring:
"abc"
left = 0
right = 0
currentSubstr = 'a'
totalPalindromes = 1 // A single character is a palindrome
로그인 후 복사
Then, we'll try to expand the substring to see if 'a' can be the middle character of another substring:
"abc"
left = -1
right = 1
currentSubstr = undefined
totalPalindromes = 1
로그인 후 복사
Now that our left pointer is out of bounds, we can jump to the next character:
"abc"
left = 1
right = 1
currentSubstr = 'b'
totalPalindromes = 2
로그인 후 복사
Now, we'll update our pointers, and indeed, 'b' can be the middle character of another substring:
s = "abc"
left = 0
right = 2
currentSubstr = 'abc'
totalPalindromes = 2
로그인 후 복사
Well, currentSubstr is not a palindrome. Now we update our pointers again:
s = "abc"
left = -1
right = 3
currentSubstr = undefined
totalPalindromes = 2
로그인 후 복사
And, we're out of bounds again. Time to move on to the next character:
s = "abc"
left = 2
right = 2
currentSubstr = 'c'
totalPalindromes = 3
로그인 후 복사
Shifting our pointers, we'll be out of bounds again:
s = "abc"
left = 1
right = 3
currentSubstr = undefined
totalPalindromes = 3
로그인 후 복사
Now that we've gone through each character, our final result of totalPalindromes is, in this case, 3. Meaning that there are 3 palindromic substrings in "abc".
However, there is an important caveat: each time we assume a character as the middle and initialize two pointers to the left and right of it, we're trying to find only odd-length palindromes. In order to mitigate that, instead of considering a single character as the middle, we can consider two characters as the middle and expand as we did before.
In this case, the process of finding the even-length substring palindromes will look like this — initially, our right pointer is left + 1:
s = "abc"
left = 0
right = 1
currentSubstr = 'ab'
totalPalindromes = 0
로그인 후 복사
Then, we'll update our pointers:
s = "abc"
left = -1
right = 2
currentSubstr = undefined
totalPalindromes = 0
로그인 후 복사
Out of bounds. On to the next character:
s = "abc"
left = 1
right = 2
currentSubstr = 'bc'
totalPalindromes = 0
로그인 후 복사
Updating our pointers:
s = "abc"
left = 0
right = 3
currentSubstr = undefined
totalPalindromes = 0
로그인 후 복사
The right pointer is out of bounds, so we go on to the next character:
s = "abc"
left = 2
right = 3
currentSubstr = undefined
totalPalindromes = 0
로그인 후 복사
Once again we're out of bounds, and we're done going through each character. There are no palindromes for even-length substrings in this example.
We can write a function that does the work of counting the palindromes in each substring:
function countPalindromes(s: string, isOddLength: boolean): number {
let result = 0;
for (let i = 0; i < s.length; i++) {
let left = i;
let right = isOddLength ? i : i + 1;
result += countPalindromesInSubstr(s, left, right);
}
return result;
}
로그인 후 복사
In our main function, we can call countPalindromes twice for both odd and even length substrings, and return the result:
function countSubstrings(s: string): number {
let result = 0;
result += countPalindromes(s, true); // Odd-length palindromes
result += countPalindromes(s, false); // Even-length palindromes
return result;
}
로그인 후 복사
Overall, our solution looks like this:
function countSubstrings(s: string): number {
let result = 0;
result += countPalindromes(s, true); // Odd-length palindromes
result += countPalindromes(s, false); // Even-length palindromes
return result;
}
function countPalindromes(s: string, isOddLength: boolean): number {
let result = 0;
for (let i = 0; i < s.length; i++) {
let left = i;
let right = isOddLength ? i : i + 1;
result += countPalindromesInSubstr(s, left, right);
}
return result;
}
function countPalindromesInSubstr(s: string, left: number, right: number): number {
let result = 0;
while (left >= 0 && right < s.length && s[left] === s[right]) {
result++;
left--;
right++;
}
return result;
}
Time and space complexity
The time complexity is
O(n2)
as we go through each substring for each character (countPalindromes is doing an
O(n2)
operation, we call it twice separately.)
The space complexity is
O(1)
as we don't have an additional data structure whose size will grow with the input size.
Next up is the problem called Decode Ways. Until then, happy coding.
위 내용은 LeetCode 명상: 회문 부분 문자열의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!