Longest subsequence with different adjacent characters
Last Updated :
28 Apr, 2025
Given string str. The task is to find the longest subsequence of str such that all the characters adjacent to each other in the subsequence are different.
Examples:Â Â
Input: str = "ababa"Â
Output: 5Â
Explanation:Â
"ababa" is the subsequence satisfying the condition
Input: str = "xxxxy"Â
Output: 2Â
Explanation:Â
"xy" is the subsequence satisfying the condition Â
Method 1: Greedy ApproachÂ
It can be observed that choosing the first character which is not similar to the previously chosen character given the longest subsequence of the given string with different adjacent characters.Â
The idea is to keep track of previously picked characters while iterating through the string, and if the current character is different from the previous character, then count the current character to find the longest subsequence.
Implementation:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find the longest Subsequence
// with different adjacent character
int longestSubsequence(string s)
{
// Length of the string s
int n = s.length();
int answer = 0;
// Previously picked character
char prev = '-';
for (int i = 0; i < n; i++) {
// If the current character is
// different from the previous
// then include this character
// and update previous character
if (prev != s[i]) {
prev = s[i];
answer++;
}
}
return answer;
}
// Driver Code
int main()
{
string str = "ababa";
// Function call
cout << longestSubsequence(str);
return 0;
}
// Java program for the above approach
import java.util.*;
class GFG {
// Function to find the longest subsequence
// with different adjacent character
static int longestSubsequence(String s)
{
// Length of the String s
int n = s.length();
int answer = 0;
// Previously picked character
char prev = '-';
for (int i = 0; i < n; i++) {
// If the current character is
// different from the previous
// then include this character
// and update previous character
if (prev != s.charAt(i)) {
prev = s.charAt(i);
answer++;
}
}
return answer;
}
// Driver Code
public static void main(String[] args)
{
String str = "ababa";
// Function call
System.out.print(longestSubsequence(str));
}
}
// This code is contributed by sapnasingh4991
# Python3 program for the above approach
# Function to find the longest Subsequence
# with different adjacent character
def longestSubsequence(s):
# Length of the string s
n = len(s)
answer = 0
# Previously picked character
prev = '-'
for i in range(0, n):
# If the current character is
# different from the previous
# then include this character
# and update previous character
if (prev != s[i]):
prev = s[i]
answer += 1
return answer
# Driver Code
str = "ababa"
# Function call
print(longestSubsequence(str))
# This code is contributed by Code_Mech
// C# program for the above approach
using System;
class GFG {
// Function to find the longest subsequence
// with different adjacent character
static int longestSubsequence(String s)
{
// Length of the String s
int n = s.Length;
int answer = 0;
// Previously picked character
char prev = '-';
for (int i = 0; i < n; i++) {
// If the current character is
// different from the previous
// then include this character
// and update previous character
if (prev != s[i]) {
prev = s[i];
answer++;
}
}
return answer;
}
// Driver Code
public static void Main(String[] args)
{
String str = "ababa";
// Function call
Console.Write(longestSubsequence(str));
}
}
// This code is contributed by amal kumar choubey
<script>
// Javascript program for the above approach
// Function to find the longest Subsequence
// with different adjacent character
function longestSubsequence(s)
{
// Length of the string s
var n = s.length;
var answer = 0;
// Previously picked character
var prev = '-';
for (var i = 0; i < n; i++) {
// If the current character is
// different from the previous
// then include this character
// and update previous character
if (prev != s[i]) {
prev = s[i];
answer++;
}
}
return answer;
}
// Driver Code
var str = "ababa";
// Function call
document.write( longestSubsequence(str));
</script>
Time Complexity: O(N), where N is the length of the given string.
Auxiliary Space: O(1), no extra space is required, so it is a constant.
Method 2: Dynamic ProgrammingÂ
- For each character in the given string str, do the following:Â
- Choose the current characters in the string for the resultant subsequence and recur for the remaining string to find the next possible characters for the resultant subsequence.
- Omit the current characters and recur for the remaining string to find the next possible characters for the resultant subsequence.
- The maximum value in the above recursive call will be the longest subsequence with different adjacent elements.
- The recurrence relation is given by:
Let dp[pos][prev] be the length of longest subsequence
till index pos such that alphabet prev was picked previously.a dp[pos][prev] = max(1 + function(pos+1, s[pos] - 'a' + 1, s),
function(pos+1, prev, s));
Below is the implementation of the above approach:Â Â
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// dp table
int dp[100005][27];
// A recursive function to find the
// update the dp[][] table
int calculate(int pos, int prev, string& s)
{
// If we reach end of the string
if (pos == s.length()) {
return 0;
}
// If subproblem has been computed
if (dp[pos][prev] != -1)
return dp[pos][prev];
// Initialise variable to find the
// maximum length
int val = 0;
// Choose the current character
if (s[pos] - 'a' + 1 != prev) {
val = max(val,
1 + calculate(pos + 1,
s[pos] - 'a' + 1,
s));
}
// Omit the current character
val = max(val, calculate(pos + 1, prev, s));
// Return the store answer to the
// current subproblem
return dp[pos][prev] = val;
}
// Function to find the longest Subsequence
// with different adjacent character
int longestSubsequence(string s)
{
// Length of the string s
int n = s.length();
// Initialise the memoisation table
memset(dp, -1, sizeof(dp));
// Return the final ans after every
// recursive call
return calculate(0, 0, s);
}
// Driver Code
int main()
{
string str = "ababa";
// Function call
cout << longestSubsequence(str);
return 0;
}
// Java program for the above approach
class GFG{
// dp table
static int dp[][] = new int[100005][27];
// A recursive function to find the
// update the dp[][] table
static int calculate(int pos, int prev, String s)
{
// If we reach end of the String
if (pos == s.length())
{
return 0;
}
// If subproblem has been computed
if (dp[pos][prev] != -1)
return dp[pos][prev];
// Initialise variable to find the
// maximum length
int val = 0;
// Choose the current character
if (s.charAt(pos) - 'a' + 1 != prev)
{
val = Math.max(val, 1 + calculate(pos + 1,
s.charAt(pos) - 'a' + 1,
s));
}
// Omit the current character
val = Math.max(val, calculate(pos + 1, prev, s));
// Return the store answer to the
// current subproblem
return dp[pos][prev] = val;
}
// Function to find the longest Subsequence
// with different adjacent character
static int longestSubsequence(String s)
{
// Length of the String s
int n = s.length();
// Initialise the memoisation table
for(int i = 0; i < 100005; i++)
{
for (int j = 0; j < 27; j++)
{
dp[i][j] = -1;
}
}
// Return the final ans after every
// recursive call
return calculate(0, 0, s);
}
// Driver Code
public static void main(String[] args)
{
String str = "ababa";
// Function call
System.out.print(longestSubsequence(str));
}
}
// This code is contributed by Rohit_ranjan
# Python3 program for the above approach
# dp table
dp = [[-1 for i in range(27)] for j in range(100005)];
# A recursive function to find the
# update the dp table
def calculate(pos, prev, s):
# If we reach end of the String
if (pos == len(s)):
return 0;
# If subproblem has been computed
if (dp[pos][prev] != -1):
return dp[pos][prev];
# Initialise variable to find the
# maximum length
val = 0;
# Choose the current character
if (ord(s[pos]) - ord('a') + 1 != prev):
val = max(val, 1 + calculate(pos + 1,
ord(s[pos]) -
ord('a') + 1, s));
# Omit the current character
val = max(val, calculate(pos + 1, prev, s));
# Return the store answer to
# the current subproblem
dp[pos][prev] = val;
return dp[pos][prev];
# Function to find the longest Subsequence
# with different adjacent character
def longestSubsequence(s):
# Length of the String s
n = len(s);
# Return the final ans after every
# recursive call
return calculate(0, 0, s);
# Driver Code
if __name__ == '__main__':
str = "ababa";
# Function call
print(longestSubsequence(str));
# This code is contributed by shikhasingrajput
// C# program for the above approach
using System;
public class GFG{
// dp table
static int [,]dp = new int[100005,27];
// A recursive function to find the
// update the [,]dp table
static int calculate(int pos, int prev, String s)
{
// If we reach end of the String
if (pos == s.Length)
{
return 0;
}
// If subproblem has been computed
if (dp[pos,prev] != -1)
return dp[pos,prev];
// Initialise variable to
// find the maximum length
int val = 0;
// Choose the current character
if (s[pos] - 'a' + 1 != prev)
{
val = Math.Max(val, 1 +
calculate(pos + 1,
s[pos] - 'a' + 1,
s));
}
// Omit the current character
val = Math.Max(val, calculate(pos + 1, prev, s));
// Return the store answer to the
// current subproblem
return dp[pos,prev] = val;
}
// Function to find the longest Subsequence
// with different adjacent character
static int longestSubsequence(String s)
{
// Length of the String s
int n = s.Length;
// Initialise the memoisation table
for(int i = 0; i < 100005; i++)
{
for (int j = 0; j < 27; j++)
{
dp[i,j] = -1;
}
}
// Return the readonly ans after every
// recursive call
return calculate(0, 0, s);
}
// Driver Code
public static void Main(String[] args)
{
String str = "ababa";
// Function call
Console.Write(longestSubsequence(str));
}
}
// This code is contributed by shikhasingrajput
<script>
// JavaScript program for the above approach
// dp table
let dp = new Array(100005);
// A recursive function to find the
// update the dp[][] table
function calculate(pos, prev, s)
{
// If we reach end of the String
if (pos == s.length)
{
return 0;
}
// If subproblem has been computed
if (dp[pos][prev] != -1)
return dp[pos][prev];
// Initialise variable to find the
// maximum length
let val = 0;
// Choose the current character
if (s[pos].charCodeAt() - 'a'.charCodeAt() + 1 != prev)
{
val = Math.max(val, 1 + calculate(pos + 1,
s[pos].charCodeAt() - 'a'.charCodeAt() + 1,
s));
}
// Omit the current character
val = Math.max(val, calculate(pos + 1, prev, s));
// Return the store answer to the
// current subproblem
dp[pos][prev] = val;
return dp[pos][prev];
}
// Function to find the longest Subsequence
// with different adjacent character
function longestSubsequence(s)
{
// Length of the String s
let n = s.length;
// Initialise the memoisation table
for(let i = 0; i < 100005; i++)
{
dp[i] = new Array(27);
for (let j = 0; j < 27; j++)
{
dp[i][j] = -1;
}
}
// Return the final ans after every
// recursive call
return calculate(0, 0, s);
}
let str = "ababa";
// Function call
document.write(longestSubsequence(str));
</script>
Time Complexity: O(N), where N is the length of the given string.Â
Auxiliary Space: O(26*N) where N is the length of the given string.
Approach 2: Using DP Tabulation method ( Iterative approach )
The approach to solving this problem is the same but DP tabulation(bottom-up) method is better then Dp + memorization(top-down) because memorization method needs extra stack space of recursion calls.
Steps to solve this problem:
- Create a vector to store the solution of the subproblems.
- Initialize the table with base cases
- Fill up the table iteratively
- Return the final solution
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
// Function to find the longest Subsequence
// with different adjacent character
int longestSubsequence(string s)
{
int n = s.length();
// dp table
int dp[n + 1][27];
// Initialise the dp table
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 26; j++) {
dp[i][j] = 0;
}
}
// Fill the dp table bottom-up
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= 26; j++) {
if (s[i] - 'a' + 1 != j) {
dp[i][j] = 1 + dp[i + 1][s[i] - 'a' + 1];
}
dp[i][j] = max(dp[i][j], dp[i + 1][j]);
}
}
// Return the final answer
return dp[0][0];
}
// Driver Code
int main()
{
string str = "ababa";
// Function call
cout << longestSubsequence(str);
return 0;
}
import java.util.Arrays;
public class Main {
// Function to find the longest Subsequence
// with different adjacent character
static int longestSubsequence(String s)
{
int n = s.length();
// dp table
int[][] dp = new int[n + 1][27];
// Initialise the dp table
for (int i = 0; i <= n; i++) {
Arrays.fill(dp[i], 0);
}
// Fill the dp table bottom-up
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= 26; j++) {
if (s.charAt(i) - 'a' + 1 != j) {
dp[i][j] = 1
+ dp[i + 1]
[s.charAt(i) - 'a' + 1];
}
dp[i][j] = Math.max(dp[i][j], dp[i + 1][j]);
}
}
// Return the final answer
return dp[0][0];
}
// Driver Code
public static void main(String[] args)
{
String str = "ababa";
// Function call
System.out.println(longestSubsequence(str));
}
}
# Function to find the longest Subsequence
# with different adjacent character
def longestSubsequence(s):
n = len(s)
# dp table
dp = [[0 for j in range(27)] for i in range(n+1)]
# Initialise the dp table
for i in range(n+1):
for j in range(27):
dp[i][j] = 0
# Fill the dp table bottom-up
for i in range(n-1, -1, -1):
for j in range(27):
if ord(s[i]) - ord('a') + 1 != j:
dp[i][j] = 1 + dp[i+1][ord(s[i])-ord('a')+1]
dp[i][j] = max(dp[i][j], dp[i+1][j])
# Return the final answer
return dp[0][0]
# Driver Code
if __name__ == '__main__':
str = "ababa"
# Function call
print(longestSubsequence(str))
using System;
public class Solution
{
// Function to find the longest Subsequence
// with different adjacent character
public static int LongestSubsequence(string s)
{
int n = s.Length;
// dp table
int[, ] dp = new int[n + 1, 27];
// Initialise the dp table
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 26; j++) {
dp[i, j] = 0;
}
}
// Fill the dp table bottom-up
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= 26; j++) {
if (s[i] - 'a' + 1 != j) {
dp[i, j]
= 1 + dp[i + 1, s[i] - 'a' + 1];
}
dp[i, j] = Math.Max(dp[i, j], dp[i + 1, j]);
}
}
// Return the final answer
return dp[0, 0];
}
// Driver Code
public static void Main(string[] args)
{
string str = "ababa";
// Function call
Console.WriteLine(LongestSubsequence(str));
}
}
// This code is contributed by user_dtewbxkn77n
// Function to find the longest Subsequence
// with different adjacent character
function longestSubsequence(s) {
let n = s.length;
// dp table
let dp = Array.from(Array(n+1), () => new Array(27).fill(0));
// Fill the dp table bottom-up
for (let i = n-1; i >= 0; i--) {
for (let j = 0; j <= 26; j++) {
if (s.charCodeAt(i) - 'a'.charCodeAt(0) + 1 != j) {
dp[i][j] = 1 + dp[i+1][s.charCodeAt(i)-'a'.charCodeAt(0)+1];
}
dp[i][j] = Math.max(dp[i][j], dp[i+1][j]);
}
}
// Return the final answer
return dp[0][0];
}
// Driver Code
let str = "ababa";
// Function call
console.log(longestSubsequence(str));
Time Complexity: O(N), where N is the length of the given string.Â
Auxiliary Space: O(N) where N is the length of the given string.
Similar Reads
Longest Common Subsequence (LCS) Given two strings, s1 and s2, the task is to find the length of the Longest Common Subsequence. If there is no common subsequence, return 0. A subsequence is a string generated from the original string by deleting 0 or more characters, without changing the relative order of the remaining characters.
15+ min read
Printing Longest Common Subsequence Given two sequences, print the longest subsequence present in both of them. Examples: LCS for input Sequences “ABCDGH†and “AEDFHR†is “ADH†of length 3. LCS for input Sequences “AGGTAB†and “GXTXAYB†is “GTAB†of length 4.We have discussed Longest Common Subsequence (LCS) problem in a previous post
15+ min read
Longest Common Subsequence | DP using Memoization Given two strings s1 and s2, the task is to find the length of the longest common subsequence present in both of them. Examples: Input: s1 = “ABCDGHâ€, s2 = “AEDFHR†Output: 3 LCS for input Sequences “AGGTAB†and “GXTXAYB†is “GTAB†of length 4. Input: s1 = “striverâ€, s2 = “raj†Output: 1 The naive s
13 min read
Longest Common Increasing Subsequence (LCS + LIS) Given two arrays, a[] and b[], find the length of the longest common increasing subsequence(LCIS). LCIS refers to a subsequence that is present in both arrays and strictly increases.Prerequisites: LCS, LIS.Examples:Input: a[] = [3, 4, 9, 1], b[] = [5, 3, 8, 9, 10, 2, 1]Output: 2Explanation: The long
15+ min read
LCS (Longest Common Subsequence) of three strings Given three strings s1, s2 and s3. Your task is to find the longest common sub-sequence in all three given sequences.Note: This problem is simply an extension of LCS.Examples: Input: s1 = "geeks" , s2 = "geeksfor", s3 = "geeksforgeeks"Output : 5Explanation: Longest common subsequence is "geeks" i.e.
15+ min read
C++ Program for Longest Common Subsequence LCS Problem Statement: Given two sequences, find the length of longest subsequence present in both of them. A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous. For example, "abc", "abg", "bdf", "aeg", '"acefg", .. etc are subsequences of "abcdefg". So
3 min read
Java Program for Longest Common Subsequence LCS Problem Statement: Given two sequences, find the length of longest subsequence present in both of them. A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous. For example, "abc", "abg", "bdf", "aeg", '"acefg", .. etc are subsequences of "abcdefg". So
4 min read
Python Program for Longest Common Subsequence LCS Problem Statement: Given two sequences, find the length of longest subsequence present in both of them. A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous. For example, "abc", "abg", "bdf", "aeg", '"acefg", .. etc are subsequences of "abcdefg". So
3 min read
Problems on LCS
Edit distance and LCS (Longest Common Subsequence)In standard Edit Distance where we are allowed 3 operations, insert, delete, and replace. Consider a variation of edit distance where we are allowed only two operations insert and delete, find edit distance in this variation. Examples: Input : str1 = "cat", st2 = "cut"Output : 2We are allowed to ins
6 min read
Length of longest common subsequence containing vowelsGiven two strings X and Y of length m and n respectively. The problem is to find the length of the longest common subsequence of strings X and Y which contains all vowel characters.Examples: Input : X = "aieef" Y = "klaief"Output : aieInput : X = "geeksforgeeks" Y = "feroeeks"Output : eoeeSource:Pay
14 min read
Longest Common Subsequence (LCS) by repeatedly swapping characters of a string with characters of another stringGiven two strings A and B of lengths N and M respectively, the task is to find the length of the longest common subsequence that can be two strings if any character from string A can be swapped with any other character from B any number of times. Examples: Input: A = "abdeff", B = "abbet"Output: 4Ex
7 min read
Longest Common Subsequence with at most k changes allowedGiven two sequence P and Q of numbers. The task is to find Longest Common Subsequence of two sequences if we are allowed to change at most k element in first sequence to any value. Examples: Input : P = { 8, 3 } Q = { 1, 3 } K = 1 Output : 2 If we change first element of first sequence from 8 to 1,
8 min read
Minimum cost to make Longest Common Subsequence of length kGiven two string X, Y and an integer k. Now the task is to convert string X with the minimum cost such that the Longest Common Subsequence of X and Y after conversion is of length k. The cost of conversion is calculated as XOR of old character value and new character value. The character value of 'a
14 min read
Longest Common SubstringGiven two strings 's1' and 's2', find the length of the longest common substring. Example: Input: s1 = "GeeksforGeeks", s2 = "GeeksQuiz" Output : 5 Explanation:The longest common substring is "Geeks" and is of length 5.Input: s1 = "abcdxyz", s2 = "xyzabcd" Output : 4Explanation:The longest common su
15+ min read
Longest Common Subsequence of two arrays out of which one array consists of distinct elements onlyGiven two arrays firstArr[], consisting of distinct elements only, and secondArr[], the task is to find the length of LCS between these 2 arrays. Examples: Input: firstArr[] = {3, 5, 1, 8}, secondArr[] = {3, 3, 5, 3, 8}Output: 3.Explanation: LCS between these two arrays is {3, 5, 8}. Input : firstAr
7 min read
Longest Repeating SubsequenceGiven a string s, the task is to find the length of the longest repeating subsequence, such that the two subsequences don't have the same string character at the same position, i.e. any ith character in the two subsequences shouldn't have the same index in the original string. Examples:Input: s= "ab
15+ min read
Longest Common Anagram SubsequenceGiven two strings str1 and str2 of length n1 and n2 respectively. The problem is to find the length of the longest subsequence which is present in both the strings in the form of anagrams. Note: The strings contain only lowercase letters. Examples: Input : str1 = "abdacp", str2 = "ckamb" Output : 3
7 min read
Length of Longest Common Subsequence with given sum KGiven two arrays a[] and b[] and an integer K, the task is to find the length of the longest common subsequence such that sum of elements is equal to K. Examples: Input: a[] = { 9, 11, 2, 1, 6, 2, 7}, b[] = {1, 2, 6, 9, 2, 3, 11, 7}, K = 18Output: 3Explanation: Subsequence { 11, 7 } and { 9, 2, 7 }
15+ min read
Longest Common Subsequence with no repeating characterGiven two strings s1 and s2, the task is to find the length of the longest common subsequence with no repeating character. Examples: Input: s1= "aabbcc", s2= "aabc"Output: 3Explanation: "aabc" is longest common subsequence but it has two repeating character 'a'.So the required longest common subsequ
10 min read
Find the Longest Common Subsequence (LCS) in given K permutationsGiven K permutations of numbers from 1 to N in a 2D array arr[][]. The task is to find the longest common subsequence of these K permutations. Examples: Input: N = 4, K = 3arr[][] = {{1, 4, 2, 3}, {4, 1, 2, 3}, {1, 2, 4, 3}}Output: 3Explanation: Longest common subsequence is {1, 2, 3} which has leng
10 min read
Find length of longest subsequence of one string which is substring of another stringGiven two strings X and Y. The task is to find the length of the longest subsequence of string X which is a substring in sequence Y.Examples: Input : X = "ABCD", Y = "BACDBDCD"Output : 3Explanation: "ACD" is longest subsequence of X which is substring of Y.Input : X = "A", Y = "A"Output : 1Perquisit
15+ min read
Length of longest common prime subsequence from two given arraysGiven two arrays arr1[] and arr2[] of length N and M respectively, the task is to find the length of the longest common prime subsequence that can be obtained from the two given arrays. Examples: Input: arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}, arr2[] = {2, 5, 6, 3, 7, 9, 8} Output: 4 Explanation: The l
11 min read
A Space Optimized Solution of LCSGiven two strings, s1 and s2, the task is to find the length of the Longest Common Subsequence. If there is no common subsequence, return 0.Examples:Input: s1 = “ABCDGHâ€, s2 = “AEDFHRâ€Output: 3Explanation: The longest subsequence present in both strings is "ADH".Input: s1 = “AGGTABâ€, s2 = “GXTXAYBâ€O
13 min read
Longest common subarray in the given two arraysGiven two arrays A[] and B[] of N and M integers respectively, the task is to find the maximum length of an equal subarray or the longest common subarray between the two given array. Examples: Input: A[] = {1, 2, 8, 2, 1}, B[] = {8, 2, 1, 4, 7} Output: 3 Explanation: The subarray that is common to b
15+ min read
Number of ways to insert a character to increase the LCS by oneGiven two strings A and B. The task is to count the number of ways to insert a character in string A to increase the length of the Longest Common Subsequence between string A and string B by 1. Examples: Input : A = "aa", B = "baaa" Output : 4 The longest common subsequence shared by string A and st
11 min read
Longest common subsequence with permutations allowedGiven two strings in lowercase, find the longest string whose permutations are subsequences of given two strings. The output longest string must be sorted. Examples: Input : str1 = "pink", str2 = "kite" Output : "ik" The string "ik" is the longest sorted string whose one permutation "ik" is subseque
7 min read
Longest subsequence such that adjacent elements have at least one common digitGiven an array arr[], the task is to find the length of the longest sub-sequence such that adjacent elements of the subsequence have at least one digit in common.Examples: Input: arr[] = [1, 12, 44, 29, 33, 96, 89] Output: 5 Explanation: The longest sub-sequence is [1 12 29 96 89]Input: arr[] = [12,
15+ min read
Longest subsequence with different adjacent charactersGiven string str. The task is to find the longest subsequence of str such that all the characters adjacent to each other in the subsequence are different. Examples:Â Â Input: str = "ababa"Â Output: 5Â Explanation:Â "ababa" is the subsequence satisfying the condition Input: str = "xxxxy"Â Output: 2Â Explan
14 min read
Longest subsequence such that difference between adjacents is oneGiven an array arr[] of size n, the task is to find the longest subsequence such that the absolute difference between adjacent elements is 1.Examples: Input: arr[] = [10, 9, 4, 5, 4, 8, 6]Output: 3Explanation: The three possible subsequences of length 3 are [10, 9, 8], [4, 5, 4], and [4, 5, 6], wher
15+ min read
Longest Uncommon SubsequenceGiven two strings, find the length of longest uncommon subsequence of the two strings. The longest uncommon subsequence is defined as the longest subsequence of one of these strings which is not a subsequence of other strings. Examples: Input : "abcd", "abc"Output : 4The longest subsequence is 4 bec
12 min read
LCS formed by consecutive segments of at least length KGiven two strings s1, s2 and K, find the length of the longest subsequence formed by consecutive segments of at least length K. Examples: Input : s1 = aggayxysdfa s2 = aggajxaaasdfa k = 4 Output : 8 Explanation: aggasdfa is the longest subsequence that can be formed by taking consecutive segments, m
9 min read
Longest Increasing Subsequence using Longest Common Subsequence AlgorithmGiven an array arr[] of N integers, the task is to find and print the Longest Increasing Subsequence.Examples: Input: arr[] = {12, 34, 1, 5, 40, 80} Output: 4 {12, 34, 40, 80} and {1, 5, 40, 80} are the longest increasing subsequences.Input: arr[] = {10, 22, 9, 33, 21, 50, 41, 60, 80} Output: 6 Prer
12 min read