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

• Difficulty Level : Easy
• Last Updated : 04 Jun, 2021

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);`   `    ``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`

## Javascript

 ``

Output

`5`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :