Skip to content
Related Articles

Related Articles

Improve Article

Length of longest Palindromic Subsequence of even length with no two adjacent characters same

  • Last Updated : 08 Oct, 2021

Given a string str, the task is to find the length of the longest palindromic subsequence of even length with no two adjacent characters same except the middle characters.

Examples: 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: str = “abscrcdba” 
Output:
Explanation: 
abccba is the required string which has no two consecutive characters same except the middle characters. Hence the length is 6



Input: str = “abcd” 
Output: 0

Approach: The idea is to form a recursive solution and store the values of the subproblems using Dynamic Programming. The following steps can be followed to compute the result: 

  • Form a recursive function which will take a string and a character which is the starting character of the subsequence.
  • If the first and last character of the string matches with the given character then remove the first and last character and call the function with all the character values from ‘a’ to ‘z’ except the given character, as the adjacent character cannot be same and find the maximum length.
  • If the first and last character of the string does not match with the given character, then find the first and last index of the given character in the string, say i, j respectively. Take the substring from i to j and call the function with substring and the given character.
  • Finally, memorise the values in an unordered map and use it if the function is again called with the same parameters.

The following is the implementation of the above approach:

C++




// C++ implementation of above approach
  
#include <bits/stdc++.h>
using namespace std;
  
#define lli long long int
  
// To store the values of subproblems
unordered_map<string, lli> dp;
  
// Function to find the
// Longest Palindromic subsequence of even
// length with no two adjacent characters same
lli solve(string s, char c)
{
    // Base cases
    // If the string length is 1 return 0
    if (s.length() == 1)
        return 0;
  
    // If the string length is 2
    if (s.length() == 2) {
  
        // Check if the characters match
        if (s[0] == s[1] && s[0] == c)
            return 1;
        else
            return 0;
    }
  
    // If the value with given parameters is
    // previously calculated
    if (dp[s + " " + c])
        return dp[s + " " + c];
  
    lli ans = 0;
  
    // If the first and last character of the
    // string matches with the given character
    if (s[0] == s[s.length() - 1] && s[0] == c) 
    {
        // Remove the first and last character
        // and call the function for all characters
        for (char c1 = 'a'; c1 <= 'z'; c1++)
            if (c1 != c)
                ans = max(
                    ans,
                    1 + solve(s.substr(1, 
                                       s.length() - 2),
                                       c1));
    }
  
    // If it does not match
    else {
  
        // Then find the first and last index of
        // given character in the given string
        for (lli i = 0; i < s.length(); i++) 
        {
            if (s[i] == c) 
            {
                for (lli j = s.length() - 1; j > i; j--)
                    if (s[j] == c) 
                    {
                        if (j == i)
                            break;
  
                        // Take the substring from i
                        // to j and call the function
                        // with substring
                        // and the given character
                        ans = solve(s.substr(i, j - i + 1),
                                    c);
                        break;
                    }
  
                break;
            }
        }
    }
  
    // Store the answer for future use
    dp[s + " " + c] = ans;
    return dp[s + " " + c];
}
  
// Driver code
int main()
{
    string s = "abscrcdba";
  
    lli ma = 0;
  
    // Check for all starting characters
    for (char c1 = 'a'; c1 <= 'z'; c1++)
        ma = max(ma, solve(s, c1) * 2);
    cout << ma << endl;
  
    return 0;
}

Java




// Java implementation of above approach
import java.util.*;
  
class GFG {
  
    // To store the values of subproblems
    static Map<String, Integer> dp = new HashMap<>();
  
    // Function to find the
    // Longest Palindromic subsequence of even
    // length with no two adjacent characters same
    static Integer solve(char[] s, char c)
    {
  
        // Base cases
        // If the String length is 1 return 0
        if (s.length == 1)
            return 0;
  
        // If the String length is 2
        if (s.length == 2) {
  
            // Check if the characters match
            if (s[0] == s[1] && s[0] == c)
                return 1;
            else
                return 0;
        }
  
        // If the value with given parameters is
        // previously calculated
        if (dp.containsKey(String.valueOf(s) + " " + c))
            return dp.get(String.valueOf(s) + " " + c);
        Integer ans = 0;
  
        // If the first and last character of the
        // String matches with the given character
        if (s[0] == s[s.length - 1] && s[0] == c)
        {
            // Remove the first and last character
            // and call the function for all characters
            for (char c1 = 'a'; c1 <= 'z'; c1++)
  
                if (c1 != c)
                    ans = Math.max(
                        ans,
                        1 + solve(Arrays.copyOfRange(
                                        s, 1
                                        s.length - 1),
                                        c1));
        }
  
        // If it does not match
        else {
  
            // Then find the first and last index of
            // given character in the given String
            for (Integer i = 0; i < s.length; i++) 
            {
                if (s[i] == c) 
                {
                    for (Integer j = s.length - 1
                         j > i;
                         j--)
                        if (s[j] == c) 
                        {
                            if (j == i)
                                break;
  
                            // Take the subString from i
                            // to j and call the function
                            // with subString
                            // and the given character
                            ans = solve(Arrays.copyOfRange(
                                            s, i, 
                                            j + 1),
                                            c);
                            break;
                        }
  
                    break;
                }
            }
        }
  
        // Store the answer for future use
        dp.put(String.valueOf(s) + " " + c, ans);
        return dp.get(String.valueOf(s) + " " + c);
    }
  
    // Driver code
    public static void main(String[] args)
    {
        String s = "abscrcdba";
  
        Integer ma = 0;
  
        // Check for all starting characters
        for (char c1 = 'a'; c1 <= 'z'; c1++)
            ma = Math.max(ma,
                          solve(s.toCharArray(), c1) * 2);
        System.out.print(ma + "\n");
    }
}
  
// This code is contributed by 29AjayKumar

Python3




# Python3 implementation of above approach
  
# To store the values of subproblems
dp = {}
  
# Function to find the
# Longest Palindromic subsequence of even
# length with no two adjacent characters same
  
  
def solve(s, c):
  
    # Base cases
    # If the string length is 1 return 0
    if (len(s) == 1):
        return 0
  
    # If the string length is 2
    if (len(s) == 2):
  
        # Check if the characters match
        if (s[0] == s[1] and s[0] == c):
            return 1
        else:
            return 0
  
    # If the value with given parameters is
    # previously calculated
    if (s + " " + c) in dp:
        return dp[s + " " + c]
  
    ans = 0
  
    # If the first and last character of the
    # string matches with the given character
    if (s[0] == s[len(s) - 1] and s[0] == c):
  
        # Remove the first and last character
        # and call the function for all characters
        for c1 in range(97, 123):
  
            if (chr(c1) != c):
                ans = max(ans, 1 + solve(
                    s[1: len(s) - 1], chr(c1)))
  
    # If it does not match
    else:
  
        # Then find the first and last index of
        # given character in the given string
        for i in range(len(s)):
  
            if (s[i] == c):
                for j in range(len(s) - 1, i, -1):
                    if (s[j] == c):
                        if (j == i):
                            break
  
                        # Take the substring from i
                        # to j and call the function
                        # with substring
                        # and the given character
                        ans = solve(s[i: j - i + 2], c)
                        break
  
                break
  
    # Store the answer for future use
    dp[s + " " + c] = ans
  
    return dp[s + " " + c]
  
  
# Driver code
if __name__ == "__main__":
  
    s = "abscrcdba"
  
    ma = 0
  
    # Check for all starting characters
    for c1 in range(97, 123):
        ma = max(ma, solve(s, chr(c1)) * 2)
  
    print(ma)
  
# This code is contributed by AnkitRai01

C#




// C# implementation of
// the above approach
using System;
using System.Collections;
using System.Collections.Generic;
  
class GFG {
  
    // To store the values of subproblems
    static Dictionary<string, int> dp
        = new Dictionary<string, int>();
  
    // Function to find the
    // Longest Palindromic subsequence of even
    // length with no two adjacent characters same
    static int solve(char[] s, char c)
    {
  
        // Base cases
        // If the String length is 1 return 0
        if (s.Length == 1)
            return 0;
  
        // If the String length is 2
        if (s.Length == 2) {
  
            // Check if the characters match
            if (s[0] == s[1] && s[0] == c)
                return 1;
            else
                return 0;
        }
  
        // If the value with given parameters is
        // previously calculated
        if (dp.ContainsKey(new string(s) + " " + c))
            return dp[new string(s) + " " + c];
  
        int ans = 0;
  
        // If the first and last character of the
        // String matches with the given character
        if (s[0] == s[s.Length - 1] && s[0] == c) 
        {
  
            // Remove the first and last character
            // and call the function for all characters
            for (char c1 = 'a'; c1 <= 'z'; c1++)
  
                if (c1 != c) {
                    int len = s.Length - 2;
                    char[] tmp = new char[len];
  
                    Array.Copy(s, 1, tmp, 0, len);
                    ans = Math.Max(ans, 1 + solve(tmp, c1));
                }
        }
  
        // If it does not match
        else {
  
            // Then find the first and last index of
            // given character in the given String
            for (int i = 0; i < s.Length; i++) 
            {
                if (s[i] == c) 
                {
                    for (int j = s.Length - 1; j > i; j--)
                        if (s[j] == c) 
                        {
                            if (j == i)
                                break;
  
                            // Take the subString from i
                            // to j and call the function
                            // with subString and the
                            // given character
                            int len = j + 1 - i;
                            char[] tmp = new char[len];
                            Array.Copy(s, i, tmp, 0, len);
                            ans = solve(tmp, c);
                            break;
                        }
                    break;
                }
            }
        }
  
        // Store the answer for future use
        dp[new string(s) + " " + c] = ans;
        return dp[new string(s) + " " + c];
    }
  
    // Driver Code
    public static void Main(string[] args)
    {
        string s = "abscrcdba";
  
        int ma = 0;
  
        // Check for all starting characters
        for (char c1 = 'a'; c1 <= 'z'; c1++)
            ma = Math.Max(ma,
                          solve(s.ToCharArray(), c1) * 2);
  
        Console.Write(ma + "\n");
    }
}
  
// This code is contributed by rutvik_56

Javascript




<script>
  
// Javascript implementation of above approach
  
// To store the values of subproblems
var dp = new Map();
  
// Function to find the
// Longest Palindromic subsequence of even
// length with no two adjacent characters same
function solve(s, c)
{
    // Base cases
    // If the string length is 1 return 0
    if (s.length == 1)
        return 0;
  
    // If the string length is 2
    if (s.length == 2) {
  
        // Check if the characters match
        if (s[0] == s[1] && s[0] == c)
            return 1;
        else
            return 0;
    }
  
    // If the value with given parameters is
    // previously calculated
    if (dp.has(s + " " + c))
        return dp.get(s + " " + c);
  
    var ans = 0;
  
    // If the first and last character of the
    // string matches with the given character
    if (s[0] == s[s.length - 1] && s[0] == c) 
    {
        // Remove the first and last character
        // and call the function for all characters
        for (var c1 = 'a'.charCodeAt(0); c1 <= 'z'.charCodeAt(0); c1++)
            if (String.fromCharCode(c1) != c)
                ans = Math.max(
                    ans,
                    1 + solve(s.substring(1, 
                                       s.length - 1),
                                       String.fromCharCode(c1)));
    }
  
    // If it does not match
    else {
  
        // Then find the first and last index of
        // given character in the given string
        for (var i = 0; i < s.length; i++) 
        {
            if (s[i] == c) 
            {
                for (var j = s.length - 1; j > i; j--)
                    if (s[j] == c) 
                    {
                        if (j == i)
                            break;
  
                        // Take the substring from i
                        // to j and call the function
                        // with substring
                        // and the given character
                        ans = solve(s.substring(i, j + 1),
                                    c);
                        break;
                    }
  
                break;
            }
        }
    }
  
    // Store the answer for future use
    dp.set(s + " " + c, ans);
    return ans;
}
  
// Driver code
var s = "abscrcdba";
var ma = 0;
// Check for all starting characters
for (var c1 = 'a'.charCodeAt(0); c1 <= 'z'.charCodeAt(0); c1++)
    ma = Math.max(ma, solve(s, String.fromCharCode(c1)) * 2);
document.write(ma);
  
</script>
Output
6

Time Complexity: O(N2)
Auxiliary Space: O(N)

Related Article: Longest Palindromic Subsequence
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :