# 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}.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ` `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 > > 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); ` ` `  `    ``cout << LongestXorSubsequence(arr, n); ` ` `  `    ``return` `0; ` `} `

## 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 `

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.