最长子序列的长度，以使相邻元素的xor不减小

给定N个正整数的序列arr ，任务是找到最长子序列的长度，以使子序列中相邻整数的xor必须不减。

例子：

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

方法：

• 使用动态编程可以解决此问题，其中dp [i]将存储以索引i结尾的最长有效子序列的长度。
• 首先，存储所有元素对(即arr [i] ^ arr [j])和元素对(i，j)的xor，然后根据xor的值对它们进行排序，因为它们需要不减小。
• 现在，如果对(i，j)的被认为是随后的最长子序列的长度与j的末端将是最大(DP [J]，1 + DP [I])。这样，为每个位置计算dp []数组的最大可能值，然后取其中的最大值。

下面是上述方法的实现：

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

输出

5

时间复杂度： O(N * N)
辅助空间： O(N)

想要从精选的最佳视频中学习并解决问题，请查看有关从基础到高级C++的C++基础课程以及有关语言和STL的C++ STL课程。要完成从学习语言到DS Algo等的更多准备工作，请参阅“完整面试准备课程” 。