在 DP 问题中使用布尔的按位存储

Question

我在 this leetcode 工作，我想知道如何使用按位操作。原因是，当我使用 lru_cache 时，我得到 isUsed is not hashable 的错误。代替 isUsed 的 bool 数组，使用 int 和按位运算而不是 bool 的最佳做法是什么

def canIWin(self, n: int, target: int) -> bool:
    @lru_cache(None)
    def isWin(isUsed, target):
        # print(isUsed,target)
        if target<=0:
            return False
        for i in reversed(range(1,n+1)):
            if not isUsed[i-1]:
                if i>=target:
                    return True
                isUsed[i-1] = True
                if not isWin(isUsed[::], target-i):
                    return True
                isUsed[i-1] = False

        return False

    if target <2:
        return True
    if n*(n+1)/2<target:
        return False
    return isWin([False]*n,target)

Answer 1

正如 kaya3 在他们的评论中提到的，您可以只使用元组而不是列表，而不是使用整数位集，因为它们是不可变的和可散列的。在元组中设置一个位有点复杂，所以将元组转换为列表可能更容易一旦你在函数内部。

---

如果你真的想使用 bitset，你必须用 2 的幂进行一些 ANDing、ORing 和 XORing：

在长度为 n 的位集中的索引 i 处设置位：

bitset = bitset | 2**(n-1-i)

稍微重置一下：

bitset = bitset & (2**n-1) ^ 2**(n-1-i)

Answer 2

您可以使用元组或使用位集。使用元组最简单的方法是将其转换为数组并将其转换回来，但是它更快地将值数组切片并传递，而不是传递布尔数组。

以下是三种方法：

1. 元组切片无布尔数组（388 毫秒）这是最快的，因为您可以通过检查最后一项来提前退出
2. 使用位集（532 毫秒）
3. 从列表转换为元组（624 毫秒）

元组切片：

def canIWin(self, n: int, target: int) -> bool:
    @lru_cache(None)
    def isWin(nums, target):
        if target <= 0:
            return False
        n = len(nums)
        if nums[-1] >= target:
            return True
        for i in range(n):
            if not isWin(nums[:i] + nums[i + 1:], target - nums[i]):
                return True
        return False
    if target < 2:
        return True
    if (n + 1) * n / 2 < target:
        return False
    return isWin(tuple(range(1, n + 1)), target)

位集：

def canIWin(self, n: int, target: int) -> bool:
    isNthBitSet = lambda x, n: (x & (1 << n) != 0)
    setNthBit = lambda x, n: x | (1 << n)
    @lru_cache(None)
    def isWin(isUsed, target):
        if target <= 0:
            return False
        for i in reversed(range(n)):
            if not isNthBitSet(isUsed, i):
                if not isWin(setNthBit(isUsed, i), target - i - 1):
                return True
    return False
if target < 2:
    return True
if n * (n + 1) / 2 < target:
    return False
return isWin(0, target)

元组列表：

def canIWin(self, n: int, target: int) -> bool:
    @lru_cache(None)
    def isWin(isUsed, target):
        isUsed = list(isUsed)
        if target <= 0:
            return False
        for i in reversed(range(1, n + 1)):
            if not isUsed[i - 1]:
                if i >= target:
                    return True
                isUsed[i - 1] = True
                if not isWin(tuple(isUsed[::]), target - i):
                    return True
                isUsed[i - 1] = False
        return False
    if target < 2:
        return True
    if n * (n + 1) / 2 < target:
        return False
    return isWin(tuple([False] * n), target)