I was solving the below problem from USACO training. I found this really fast solution for which, I am finding it unable to absorb fully.

Problem: Consider an ordered set S of strings of N (1 <= N <= 31) bits. Bits, of course, are either 0 or 1.

This set of strings is interesting because it is ordered and contains all possible strings of length N that have L (1 <= L <= N) or fewer bits that are `1'.

Your task is to read a number I (1 <= I <= sizeof(S)) from the input and print the Ith element of the ordered set for N bits with no more than L bits that are `1'.

sample input: 5 3 19 output: 10110

The two solutions I could think of: Firstly the brute force solution which goes through all possible combinations of bits, selects and stores the strings whose count of '1's are less than equal to 'L' and returning the Ith string.

Secondly, we can find all the permutations of '1's from 5 positions with range of count(0 to L), sort the strings in increasing order and returning the Ith string.

The best Solution: The OP who posted the solution has used combination instead of permutation. According to him, the total number of string possible is 5C0 5C1 5C2 5C3.

So at every position i of the string, we decide whether to include the ith bit in our output or not, based on the total number of ways we have to build the rest of the string. Below is a dry run of the entire approach for the above input.

N = 5, L = 3, I = 19
00000
at i = 0, for the rem string, we have 4C0   4C1   4C2   4C3 = 15
It says that, there are 15 other numbers possible with the last 4 positions. as 15 is less than 19, our first bit has to be set.

N = 5, L = 2, I = 4
10000
at i = 1, we have 3C0   3C1   3C2 (as we have used 1 from L) = 7
as 7 is greater than 4, we cannot set this bit. 

N = 5, L = 2, I = 4
10000
at i = 2 we have 2C0   2C2 = 2
as 2 <= I(4), we take this bit in our output.

N = 5, L = 1, I = 2
10100
at i = 3, we have 1C0   1C1 = 2
as 2 <= I(2) we can take this bit in our output.

as L == 0, we stop and 10110 is our answer. I was amazed to find this solution. However, I am finding it difficult to get the intuition behind this solution.

How does this solution sort-of zero in directly to the Ith number in the set?

Why does the order of the bits not matter in the combinations of set bits?

CodePudding user response：

Suppose we have precomputed the number of strings of length n with k or fewer bits set. Call that S(n, k).

Now suppose we want the i'th string (in lexicographic order) of length N with L or fewer bits set.

All the strings with the most significant bit zero come before those with the most significant bit 1. There's S(N-1, L) strings with the most significant bit zero, and S(N-1, L-1) strings with the most significant bit 1. So if we want the i'th string, if i<=S(N-1, L), then it must have the top bit zero and the remainder must be the i'th string of length N-1 with at most L bits set, and otherwise it must have the top bit one, and the remainder must be the (i-S(N-1, L))'th string of length N-1 with at most L-1 bits set.

All that remains to code is to precompute S(n, k), and to handle the base cases.

You can figure out a combinatorial solution to S(n, k) as your friend did, but it's more practical to use a recurrence relation: S(n, k) = S(n-1, k) S(n-1, k-1), and S(0, k) = S(n, 0) = 1.

Here's code that does all that, and as an example prints out all 8-bit numbers with 3 or fewer bits set, in lexicographic order. If i is out of range, then it raises an IndexError exception, although in your question you assume i is always in range, so perhaps that's not necessary.

S = [[1] * 32 for _ in range(32)]
for n in range(1, 32):
    for k in range(1, 32):
        S[n][k] = S[n-1][k]   S[n-1][k-1]

def ith_string(n, k, i):
    if n == 0:
        if i != 1:
            raise IndexError
        return ''
    elif i <= S[n-1][k]:
        return "0"   ith_string(n-1, k, i)
    elif k == 0:
        raise IndexError
    else:
        return "1"   ith_string(n-1, k-1, i - S[n-1][k])

print([ith_string(8, 3, i) for i in range(1, 94)])