给定一个长度为 n 的数组，找到子集的 XOR 等于给定数字的子集数

Question

给定一个长度为n 的数组arr，找出有多少arr 的子集使得这些子集中的XOR(^) 等于给定的数字ans。

我有这种dp 方法，但有没有办法提高它的时间复杂度。 ans 总是小于 1024。

这里ans 是第。这样子集的XOR(^) 等于它。 arr[n] 包含所有数字

memset(dp, 0, sizeof(dp));
dp[0][0] = 1;

for(i = 1; i <= n; i++){
    for(j = 0; j < 1024; j++) {
        dp[i][j] = (dp[i-1][j] + dp[i-1][j^arr[i]]);
    }
}

cout << (dp[n][ans]);

Answer 1

来自user3386109 的评论，建立在您的代码之上：

/* Warning: Untested */
int counts[1024] = {0}, ways[1024];
for(int i = 1; i <= n; ++i) counts[ arr[i] ] += 1;
for(int i = 0; i <= 1024; ++i) {
  const int z = counts[i];
  // Look for overflow here
  ways[i] = z == 0 ?
              0 :
              (int)(1U << (z-1));
}

memset(dp, 0, sizeof(dp));
dp[0][0] = 1;

for(i = 1; i <= 1024; i++){
    for(j = 0; j < 1024; j++) {
        // Check for overflow
        const int howmany = ways[i] * dp[i-1][j];
        dp[i][j] += howmany;
        dp[i][j^i] += howmany;
    }
}

cout << (dp[1024][ans]);

对于计算odd_ 和even_，您还可以使用以下内容：

ⁿc₀+ⁿc₂+... = ⁿc₁+ⁿc₃... = 2^n-1

因为选择奇数的方法数=拒绝奇数的方法数=选择偶数的方法数

您还可以通过仅保留 2 列 dp 数组并在 dp[i-2][x] 被丢弃时重用它们来优化空间。

Answer 2

动态编程背后的理念是，(1) 永远不要两次计算相同的结果，(2) 只根据需要计算结果，而不是在你做的时候预先计算整个事情。

所以solve(arr, n, ans) 需要一个解决方案ans < 1024、n < 1000000 和arr = array[n]。让dp[n][ans] 保存结果数量的想法是合理的，因此需要 dp 大小为dp = array[n+1][1024]。我们需要一种方法来区分尚未计算的结果和可用的结果。所以memset(dp, -1, sizeof(dp)) 然后就像你已经做过的dp[0][0] = 1

solve(arr, n, ans):
    if (dp[n][ans] == -1)
        if (n == 0) // and ans != 0 since that was initialized already
            dp[n][ans] = 0
        else
            // combine results with current and without current array element
            dp[n][ans] = solve(arr + 1, n - 1, ans) + solve(arr + 1, n - 1, ans XOR arr[0])
    return dp[n][ans]

优点是，您的 dp 数组只是在解决方案的途中部分计算，因此这可能会节省一些时间。

根据堆栈大小和n，可能需要将其从递归解决方案转换为迭代解决方案