Open In App

# Length of longest subsequence consisting of distinct adjacent elements

Given an array arr[], the task is to find the length of the longest subsequence of the array arr[] such that all adjacent elements in the subsequence are different.

Examples:

Input: arr[] = {4, 2, 3, 4, 3}
Output: 5
Explanation:
The longest subsequence where no two adjacent elements are equal is {4, 2, 3, 4, 3}. Length of the subsequence is 5.

Input: arr[] = {7, 8, 1, 2, 2, 5, 5, 1}
Output: 6
Explanation: Longest subsequence where no two adjacent elements are equal is {7, 8, 1, 2, 5, 1}. Length of the subsequence is 5.

Naive Approach: The simplest approach is to generate all possible subsequence of the given array and print the maximum length of that subsequence having all adjacent elements different.

Time Complexity: O(2N)
Auxiliary Space: O(1)

Efficient Approach: Follow the steps below to solve the problem:

• Initialize count to 1 to store the length of the longest subsequence.
• Traverse the array over the indices [1, N – 1] and for each element, check if the current element is equal to the previous element or not. If found to be not equal, then increment count by 1.
• After completing the above steps, print the value of count as the maximum possible length of subsequence.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach#include using namespace std; // Function that finds the length of// longest subsequence having different// adjacent elementsvoid longestSubsequence(int arr[], int N){    // Stores the length of the    // longest subsequence    int count = 1;     // Traverse the array    for (int i = 1; i < N; i++) {         // If previous and current        // element are not same        if (arr[i] != arr[i - 1]) {             // Increment the count            count++;        }    }     // Print the maximum length    cout << count << endl;} // Driver Codeint main(){    int arr[] = { 7, 8, 1, 2, 2, 5, 5, 1 };     // Size of Array    int N = sizeof(arr) / sizeof(arr[0]);     // Function Call    longestSubsequence(arr, N);     return 0;}

## Java

 // Java program for the// above approachimport java.util.*; class GFG{    // Function that finds the length of// longest subsequence having different// adjacent elementsstatic void longestSubsequence(int arr[],                               int N){  // Stores the length of the  // longest subsequence  int count = 1;   // Traverse the array  for (int i = 1; i < N; i++)  {    // If previous and current    // element are not same    if (arr[i] != arr[i - 1])    {      // Increment the count      count++;    }  }   // Print the maximum length  System.out.println(count);} // Driver Codepublic static void main(String args[]){  int arr[] = {7, 8, 1, 2,               2, 5, 5, 1};   // Size of Array  int N = arr.length;   // Function Call  longestSubsequence(arr, N);}} // This code is contributed by bgangwar59

## Python3

 # Python3 program for the above approach # Function that finds the length of# longest subsequence having different# adjacent elementsdef longestSubsequence(arr, N):         # Stores the length of the    # longest subsequence    count = 1     # Traverse the array    for i in range(1, N, 1):                 # If previous and current        # element are not same        if (arr[i] != arr[i - 1]):                         # Increment the count            count += 1     # Print the maximum length    print(count) # Driver Codeif __name__ == '__main__':         arr = [ 7, 8, 1, 2, 2, 5, 5, 1 ]         # Size of Array    N = len(arr)         # Function Call    longestSubsequence(arr, N) # This code is contributed by ipg2016107

## C#

 // C# program for the// above approachusing System;  class GFG{     // Function that finds the length of// longest subsequence having different// adjacent elementsstatic void longestSubsequence(int[] arr,                               int N){     // Stores the length of the  // longest subsequence  int count = 1;    // Traverse the array  for(int i = 1; i < N; i++)  {         // If previous and current    // element are not same    if (arr[i] != arr[i - 1])    {             // Increment the count      count++;    }  }    // Print the maximum length  Console.WriteLine(count);}  // Driver Codepublic static void Main(){  int[] arr = { 7, 8, 1, 2,                2, 5, 5, 1 };     // Size of Array  int N = arr.Length;     // Function Call  longestSubsequence(arr, N);}} // This code is contributed by susmitakundugoaldanga

## Javascript



Output:

6

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