Palindromic Substrings

Palindromic Substrings

Given a string, your task is to count how many palindromic substrings in this string.

The substrings with different start indexes or end indexes are counted as different substrings even they consist of same characters.

Example 1:

Input: "abc"
Output: 3
Explanation: Three palindromic strings: "a", "b", "c".

Example 2:

Input: "aaa"
Output: 6
Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".

Note:
The input string length won’t exceed 1000.

Solution 1

The simplest and most violent solution is to enumerate all the cases (see the below graph), for string “abacb”:

                a(*)     b(*)  a(*)   c(*)    b(*)      
                |         |     ...    ...   ...
                ab        ba
                |         |
                aba(*)    bac
                |         | 
                abac     bacb
                |
                abacb

substrs marked with * are palindromic. We just need two loops [O(n*n)] to enumerate all the possible substrings, and use a loop [O(n)] to judge whether the substring is palindromic. If true, accumulate the number of palindromic substrings. Finally, the time complexity is O(n^3), space complexity is O(1).

class Solution {
public:
    int countSubstrings(string s) {
        return method1(s);
    }

private:
    int method1(string s)
    {
        int n = s.size();
        int res = 0;
        for (int i = 0; i < n; ++i)
        {
            for (int j = i; j < n; ++j)
            {
                if (isPalindromic(s.substr(i, j - i + 1)))
                {
                    ++res;
                }
            }
        }
        return res;
    }

    bool isPalindromic(string s)
    {
        int n = s.size();
        for (int i = 0; i < n / 2; ++i)
        {
            if (s[i] != s[n - 1 - i]) return false;
        }
        return true;
    }
};

Solution 2

The problem can be defined recursively (refer to GeeksforGeeks). So there is a recursive solution.

Function: int palindromicSubstrNum(string s, int start, int end);
Stop condition:
    if (start < end) return 0;
    if (start == end) return 1;
Recursive Logic:
    int res = isPalindromic(s, start, end) ? 1 : 0;
    return res + palindromicSubstrNum(s, start, end - 1) + palindromicSubstrNum(s, start + 1, end) - palindromicSubstrNum(start + 1, end - 1);

There’s so many overlapping subproblems. For overlapping subproblems, we can use dynamic programming to solve it more efficiently.
Q1: What is the time complexity of the recursive solution ?

Solution 3