相邻对的最小可能最大异或的排列计数

在计算机科学中，一种被广泛应用于密码学、数据结构等领域的运算称为异或运算。异或运算（XOR，也称为“exclusive or”）是二元运算符，它以两个等长的二进制数为操作数，按位进行异或运算。其操作方法如下：

0 ⊕ 0 = 0 0 ⊕ 1 = 1 1 ⊕ 0 = 1 1 ⊕ 1 = 0

异或运算在排列问题中也有着广泛的应用。对于一个长度为n的排列p，它的相邻对定义为逆序对中相邻的数对。

例如，对于排列[5,4,3,2,1]，其中的相邻对为(5,4),(4,3),(3,2),(2,1)。

那么，相邻对的最小可能最大异或指的是所有相邻对的异或值中最小值的最大值。我们的任务是给定一个长度为n的排列p，计算所有排列中相邻对的最小可能最大异或的排列数。

算法一：暴力

最朴素的算法是枚举所有的排列，然后依次计算它们的相邻对的异或值，最终取所有异或值中的最小值的最大值。

时间复杂度：O(n! * n)

def brute_force(n):
    ans = 0
    for p in permutations(range(1, n+1)):
        xors = [p[i] ^ p[i+1] for i in range(n-1)]
        m = min(xors)
        ans += all(m < p[i] ^ p[i+1] for i in range(n-1))
    return ans

算法二：贪心

我们知道，异或运算具有性质：若a ^ b = c，则有c ^ b = a，c ^ a = b。也就是说，只有3个数中有2个数相同时，它们的异或值才可能等于另一个数。因此，我们可以考虑贪心策略，尽可能让排列中相邻的数均匀分布。具体做法是：

1. 将排列p按从大到小排序；
2. 将相邻的数对从中间开始，依次填入1、2、3……，直到最后一个数对；
3. 将相邻的数对从两端开始，依次填入1、2、3……，直到中间一个数对。

时间复杂度：O(n * log(n))

def greedy(n):
    p = sorted(range(1, n+1),key=lambda x:-x)
    mid = n // 2
    xors = []
    for i in range(mid):
        xors.append(p[i] ^ p[n-i-1])
    if n & 1:
        xors.append(0)
    ans = 1
    for i, x in enumerate(sorted(xors)):
        if x > i:
            ans = 0
            break
    return ans

算法三：动态规划

从贪心的做法中可以发现，关键在于如何来构造一个良好的序列。根据这个思路，我们可以设计出一个动态规划算法来解决该问题。

设dp[i][j][0/1]表示前i个数已经处理完，最大异或值为j，且最后一个数加没加入异或序列0/1。状态转移方程如下：

dp[i][j][0] = dp[i-1][j][0] + dp[i-1][j^a[i]][1] dp[i][j][1] = dp[i-1][j][1] + dp[i-1][j^a[i]][0]

其中a[i]表示第i个数。

时间复杂度：O(n * max_xor)

def dp(n):
    a = list(range(1, n+1))
    max_xor = 0
    for i in range(n):
        max_xor |= a[i]
    dp = [[[0]*2 for _ in range(max_xor+1)] for _ in range(n+1)]
    dp[0][0][0] = 1
    for i in range(1, n+1):
        for j in range(max_xor+1):
            dp[i][j][0] = dp[i-1][j][0] + dp[i-1][j^a[i-1]][1]
            dp[i][j][1] = dp[i-1][j][1] + dp[i-1][j^a[i-1]][0]
    ans = 0
    for j in range(max_xor+1):
        if dp[n][j][0] + dp[n][j][1] == 1:
            ans += 1
    return ans