# 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:5Explanation:

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:6Explanation: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(2^{N})**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 <bits/stdc++.h>` `using` `namespace` `std;` `// Function that finds the length of` `// longest subsequence having different` `// adjacent elements` `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` ` ` `cout << count << endl;` `}` `// Driver Code` `int` `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 approach` `import` `java.util.*;` `class` `GFG{` ` ` `// Function that finds the length of` `// longest subsequence having different` `// adjacent elements` `static` `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 Code` `public` `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 elements` `def` `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 Code` `if` `__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 approach` `using` `System;` ` ` `class` `GFG{` ` ` `// Function that finds the length of` `// longest subsequence having different` `// adjacent elements` `static` `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 Code` `public` `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

`<script>` `// JavaScript program to implement` `// the above approach` `// Function that finds the length of` `// longest subsequence having different` `// adjacent elements` `function` `longestSubsequence(arr, N)` `{` ` ` `// Stores the length of the` ` ` `// longest subsequence` ` ` `let count = 1;` ` ` ` ` `// Traverse the array` ` ` `for` `(let 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` ` ` `document.write(count);` `}` `// Driver Code` ` ` `let arr = [7, 8, 1, 2,` ` ` `2, 5, 5, 1];` ` ` ` ` `// Size of Array` ` ` `let N = arr.length;` ` ` ` ` `// Function Call` ` ` `longestSubsequence(arr, N);` ` ` `</script>` |

**Output:**

6

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