背包表只改了循环方向，为什么一件物品突然能拿两次？

"""One storage row, two loop directions, two different inventory rules."""
from itertools import product


def require(ok, message):
    if not ok:
        raise AssertionError(message)


def validate(items, capacity):
    if type(capacity) is not int or not 0 <= capacity <= 30:
        raise ValueError("integer capacity in 0..30 required")
    if not isinstance(items, (list, tuple)) or len(items) > 12:
        raise ValueError("at most 12 items required")
    for item in items:
        if not isinstance(item, (list, tuple)) or len(item) != 2:
            raise ValueError("each item is (weight, value)")
        weight, value = item
        if type(weight) is not int or not 1 <= weight <= 30:
            raise ValueError("positive integer weight in 1..30 required")
        if type(value) is not int or not 0 <= value <= 100:
            raise ValueError("integer value in 0..100 required")


def knapsack(items, capacity, ascending=False):
    validate(items, capacity)
    if type(ascending) is not bool:
        raise ValueError("ascending must be bool")
    dp = [0] * (capacity + 1)
    trace = []
    for index, (weight, value) in enumerate(items):
        positions = range(weight, capacity + 1) if ascending else range(capacity, weight - 1, -1)
        for c in positions:
            read = dp[c - weight]
            before = dp[c]
            dp[c] = max(before, read + value)
            trace.append((index, c, c - weight, read, before, dp[c]))
    return dp, trace


def subset_reference(items, capacity):
    best = 0
    for mask in range(1 << len(items)):
        chosen = [item for i, item in enumerate(items) if mask & (1 << i)]
        if sum(weight for weight, _ in chosen) <= capacity:
            best = max(best, sum(value for _, value in chosen))
    return best


def unlimited_reference(items, capacity, index=0):
    # Independent enumeration of the number of copies, without a DP array.
    if index == len(items):
        return 0
    weight, value = items[index]
    return max(copies * value + unlimited_reference(items, capacity - copies * weight, index + 1)
               for copies in range(capacity // weight + 1))


def main():
    items, capacity = [(2, 3)], 4
    descending, _ = knapsack(items, capacity)
    ascending, steps = knapsack(items, capacity, True)
    print(f"one_item={items}; capacity={capacity}")
    print(f"descending={descending}; answer={descending[-1]}")
    print(f"ascending={ascending}; answer={ascending[-1]}")
    print(f"ascending_last_update: capacity={steps[-1][1]}; reads_dp[{steps[-1][2]}]={steps[-1][3]}")
    require((descending[-1], ascending[-1]) == (3, 6), "reuse witness")
    count = 0
    alphabet = tuple(product(range(1, 4), range(4)))
    for size in range(4):
        for items in product(alphabet, repeat=size):
            for capacity in range(9):
                once, _ = knapsack(items, capacity)
                reusable, _ = knapsack(items, capacity, True)
                require(once[-1] == subset_reference(items, capacity), "0/1 subset oracle")
                require(reusable[-1] == unlimited_reference(items, capacity), "unlimited copy oracle")
                count += 1
    invalid = [([(0, 3)], 4), ([(2, -1)], 4), ([(True, 3)], 4), ([(2, 3)], True),
               ([(2, 3)], -1), ([(2, 3)], 31), ([(2, 3.5)], 4), ([(2,)], 4)]
    for items, capacity in invalid:
        try:
            knapsack(items, capacity)
        except ValueError:
            pass
        else:
            raise AssertionError("invalid input accepted")
    print(f"cases={count}; independent_oracles=subsets+copy_counts; invalid_inputs={len(invalid)}")
    print("PASS: descending uses each item once; ascending allows repeated copies")


if __name__ == "__main__":
    main()