# Length of the longest subsequence such that xor of adjacent elements is non-decreasing

Given a sequence **arr** of **N** positive integers, the task is to find the length of the longest subsequence such that xor of adjacent integers in the subsequence must be **non-decreasing**.

**Examples:**

Input:N = 8, arr = {1, 100, 3, 64, 0, 5, 2, 15}

Output:6

The subsequence of maximum length is {1, 3, 0, 5, 2, 15}

with XOR of adjacent elements as {2, 3, 5, 7, 13}

Input:N = 3, arr = {1, 7, 10}

Output:3

The subsequence of maximum length is {1, 3, 7}

with XOR of adjacent elements as {2, 4}.

**Approach:**

- This problem can be solved using dynamic programming where
**dp[i]**will store the length of the longest valid subsequence that ends at index**i**. - First, store the xor of all the pairs of elements i.e.
**arr[i] ^ arr[j]**and the pair**(i, j)**also and then sort them according to the value of xor as they need to be non-decreasing. - Now if the pair
**(i, j)**is considered then the length of the longest subsequence that ends at**j**will be**max(dp[j], 1 + dp[i])**. In this way, calculate the maximum possible value of**dp[]**array for each position and then take the maximum of them.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to find the length of the longest ` `// subsequence such that the XOR of adjacent ` `// elements in the subsequence must ` `// be non-decreasing ` `int` `LongestXorSubsequence(` `int` `arr[], ` `int` `n) ` `{ ` ` ` ` ` `vector<pair<` `int` `, pair<` `int` `, ` `int` `> > > v; ` ` ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `for` `(` `int` `j = i + 1; j < n; j++) { ` ` ` ` ` `// Computing xor of all the pairs ` ` ` `// of elements and store them ` ` ` `// along with the pair (i, j) ` ` ` `v.push_back(make_pair(arr[i] ^ arr[j], ` ` ` `make_pair(i, j))); ` ` ` `} ` ` ` `} ` ` ` ` ` `// Sort all possible xor values ` ` ` `sort(v.begin(), v.end()); ` ` ` ` ` `int` `dp[n]; ` ` ` ` ` `// Initialize the dp array ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `dp[i] = 1; ` ` ` `} ` ` ` ` ` `// Calculating the dp array ` ` ` `// for each possible position ` ` ` `// and calculating the max length ` ` ` `// that ends at a particular index ` ` ` `for` `(` `auto` `i : v) { ` ` ` `dp[i.second.second] ` ` ` `= max(dp[i.second.second], ` ` ` `1 + dp[i.second.first]); ` ` ` `} ` ` ` ` ` `int` `ans = 1; ` ` ` ` ` `// Taking maximum of all position ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `ans = max(ans, dp[i]); ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` ` ` `int` `arr[] = { 2, 12, 6, 7, 13, 14, 8, 6 }; ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` ` ` `cout << LongestXorSubsequence(arr, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` ` ` `# Function to find the length of the longest ` `# subsequence such that the XOR of adjacent ` `# elements in the subsequence must ` `# be non-decreasing ` `def` `LongestXorSubsequence(arr, n): ` ` ` ` ` `v ` `=` `[] ` ` ` ` ` `for` `i ` `in` `range` `(` `0` `, n): ` ` ` `for` `j ` `in` `range` `(i ` `+` `1` `, n): ` ` ` ` ` `# Computing xor of all the pairs ` ` ` `# of elements and store them ` ` ` `# along with the pair (i, j) ` ` ` `v.append([(arr[i] ^ arr[j]), (i, j)]) ` ` ` ` ` `# v.push_back(make_pair(arr[i] ^ arr[j], make_pair(i, j))) ` ` ` ` ` `# Sort all possible xor values ` ` ` `v.sort() ` ` ` ` ` `# Initialize the dp array ` ` ` `dp ` `=` `[` `1` `for` `x ` `in` `range` `(` `88` `)] ` ` ` ` ` `# Calculating the dp array ` ` ` `# for each possible position ` ` ` `# and calculating the max length ` ` ` `# that ends at a particular index ` ` ` `for` `a, b ` `in` `v: ` ` ` `dp[b[` `1` `]] ` `=` `max` `(dp[b[` `1` `]], ` `1` `+` `dp[b[` `0` `]]) ` ` ` ` ` `ans ` `=` `1` ` ` ` ` `# Taking maximum of all position ` ` ` `for` `i ` `in` `range` `(` `0` `, n): ` ` ` `ans ` `=` `max` `(ans, dp[i]) ` ` ` ` ` `return` `ans ` ` ` `# Driver code ` `arr ` `=` `[ ` `2` `, ` `12` `, ` `6` `, ` `7` `, ` `13` `, ` `14` `, ` `8` `, ` `6` `] ` `n ` `=` `len` `(arr) ` `print` `(LongestXorSubsequence(arr, n)) ` ` ` `# This code is contributed by Sanjit Prasad ` |

*chevron_right*

*filter_none*

**Output:**

5

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

## Recommended Posts:

- Length of the longest increasing subsequence such that no two adjacent elements are coprime
- Length of longest Palindromic Subsequence of even length with no two adjacent characters same
- Maximum length subsequence such that adjacent elements in the subsequence have a common factor
- Longest subsequence such that adjacent elements have at least one common digit
- Maximum length subsequence with difference between adjacent elements as either 0 or 1
- Longest subsequence with different adjacent characters
- Length of Longest Balanced Subsequence
- Length of longest common subsequence containing vowels
- Length of longest strict bitonic subsequence
- Length of Longest Prime Subsequence in an Array
- Find length of longest Fibonacci like subsequence
- Length of longest subsequence of Fibonacci Numbers in an Array
- Find the length of the longest subsequence with first K alphabets having same frequency
- Length of longest increasing index dividing subsequence
- Length of Longest Perfect number Subsequence in an Array
- Length of longest Powerful number subsequence in an Array
- Maximum subsequence sum of at most K-distant adjacent elements
- Minimum cost to make Longest Common Subsequence of length k
- Maximum subsequence sum with adjacent elements having atleast K difference in index
- Minimal product subsequence where adjacent elements are separated by a maximum distance of K

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.