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

• Difficulty Level : Easy
• Last Updated : 04 Jul, 2022

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

## Java

 `// Java implementation of the approach` `import` `java.io.*;` `import` `java.util.*;` `import` `java.util.stream.Collectors;`   `class` `GFG {` `    ``// Function to find the length of the longest` `    ``// subsequence such that the XOR of adjacent` `    ``// elements in the subsequence must` `    ``// be non-decreasing` `    ``static` `int` `LongestXorSubsequence(``int``[] arr, ``int` `n)` `    ``{`   `        ``List<``int``[]> v = ``new` `ArrayList<>();`   `        ``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)` `                ``int``[] l1 = { arr[i] ^ arr[j], i, j };` `                ``v.add(l1);` `            ``}` `        ``}`   `        ``// Sort all possible xor values` `        ``Comparator<``int``[]> byFirstElement` `            ``= (``int``[] a, ``int``[] b) -> a[``0``] - b[``0``];`   `        ``List<``int``[]> v1 = v.stream()` `                             ``.sorted(byFirstElement)` `                             ``.collect(Collectors.toList());`   `        ``int``[] dp = ``new` `int``[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` `        ``Iterator<``int``[]> iter = v1.iterator();` `        ``while` `(iter.hasNext()) {` `            ``int``[] list = iter.next();` `            ``dp[list[``2``]]` `                ``= Math.max(dp[list[``2``]], ``1` `+ dp[list[``1``]]);` `        ``}`   `        ``int` `ans = ``1``;`   `        ``// Taking maximum of all position` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``ans = Math.max(ans, dp[i]);`   `        ``return` `ans;` `    ``}` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Driver code` `        ``int``[] arr = { ``2``, ``12``, ``6``, ``7``, ``13``, ``14``, ``8``, ``6` `};` `        ``int` `n = arr.length;`   `        ``System.out.println(LongestXorSubsequence(arr, n));` `    ``}` `}`   `// this code is contributed by phasing17`

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

## C#

 `// C# implementation of the approach` `using` `System;` `using` `System.Linq;` `using` `System.Collections.Generic;`   `class` `GFG` `{`   `  ``// Function to find the length of the longest` `  ``// subsequence such that the XOR of adjacent` `  ``// elements in the subsequence must` `  ``// be non-decreasing` `  ``static` `int` `LongestXorSubsequence(``int``[] arr, ``int` `n)` `  ``{`   `    ``List<``int``[]> v = ``new` `List<``int``[]>();`   `    ``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)` `        ``int``[] l1 = { arr[i] ^ arr[j], i, j };` `        ``v.Add(l1);` `      ``}` `    ``}`   `    ``// Sorting the array by First Value` `    ``List<``int``[]> v1 = v.OrderBy(a => a)` `      ``.ThenBy(a => a)` `      ``.ToList();`   `    ``int``[] dp = ``new` `int``[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` `    ``foreach``(``var` `list ``in` `v1) dp[list]` `      ``= Math.Max(dp[list], 1 + dp[list]);`   `    ``int` `ans = 1;`   `    ``// Taking maximum of all position` `    ``for` `(``int` `i = 0; i < n; i++)` `      ``ans = Math.Max(ans, dp[i]);`   `    ``return` `ans;` `  ``}` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``// Driver code` `    ``int``[] arr = { 2, 12, 6, 7, 13, 14, 8, 6 };` `    ``int` `n = arr.Length;`   `    ``Console.WriteLine(LongestXorSubsequence(arr, n));` `  ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 ``

Output

`5`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :