Skip to content
Related Articles

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

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 foundation plus STL.



My Personal Notes arrow_drop_up
Recommended Articles
Page :