Related Articles
Length of the longest subsequence such that xor of adjacent elements is non-decreasing
• Difficulty Level : Easy
• Last Updated : 09 Nov, 2020

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:
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:
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 ``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[0]);` `    ``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`

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

Want to learn from the best curated videos and practice problems, check out the C++ Foundation Course for Basic to Advanced C++ and C++ STL Course for the language and STL.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up