2

I'm having trouble with SPOJ Problem 423: Assignments.

The problem asks me to count the number of possible assignments for n unique topics to n unique students so that each student gets exactly one topic that he/she likes. I have come up with a way to parse the input into a list of lists called preferences. Each inner list is a list of topics (denoted by an integer between 0 and n-1 inclusive) that one student likes.

For example for the input:

1 1 1
1 1 1
1 1 1

I get [[0, 1, 2], [0, 1, 2], [0, 1, 2]].

And for the input:

1 0 0 1 0 0 0 0 0 1 1 
1 1 1 1 1 0 1 0 1 0 0 
1 0 0 1 0 0 1 1 0 1 0 
1 0 1 1 1 0 1 1 0 1 1 
0 1 1 1 0 1 0 0 1 1 1 
1 1 1 0 0 1 0 0 0 0 0 
0 0 0 0 1 0 1 0 0 0 1 
1 0 1 1 0 0 0 0 0 0 1 
0 0 1 0 1 1 0 0 0 1 1 
1 1 1 0 0 0 1 0 1 0 1 
1 0 0 0 1 1 1 1 0 0 0

I get the list [[0, 3, 9, 10], [0, 1, 2, 3, 4, 6, 8], [0, 3, 6, 7, 9], [0, 2, 3, 4, 6, 7, 9, 10], [1, 2, 3, 5, 8, 9, 10], [0, 1, 2, 5], [4, 6, 10], [0, 2, 3, 10], [2, 4, 5, 9, 10], [0, 1, 2, 6, 8, 10], [0, 4, 5, 6, 7]].

Now what I need to do is count the number of ways I can select a unique number from each inner list so that no element is selected twice and each number between 0 and n-1 inclusive is selected exactly once among all selections. For the first example input, this is trivial, it's 3! = 6. But in the second example, it is hard for me to figure out a way to count the number of valid selections. They give the answer as 7588 for the second input but I don't know how to reach that answer.

I already tried the brute force method of finding all permutations of [0,...,n-1] and trying to see if they are valid combinations based on set membership but it was far too slow and it literally crashed my computer when I tried to iterate through the 11! = 39916800 permutations. So what I need to do is find a more efficient method of counting this.

Here is my code so far. All it currently does is parse the input from stdin into a list of lists called preferences and print it to stdout.

def main():
    t = int(raw_input())
    from itertools import repeat
    for _ in repeat(None, t):
        n = int(raw_input())
        preferences = [[] for _ in repeat(None, n)]
        for student in xrange(n):
            row = map(int, raw_input().split())
            for i in xrange(len(row)):
                if row[i] == 1:
                    preferences[student].append(i)
        print preferences


if __name__ == '__main__':
    main()

Is there any method I can use to count this efficiently? Any hints/tips are welcome. I don't expect anyone to solve the problem for me. I am just confused as to how I should approach this.

Shashank
  • 13,713
  • 5
  • 37
  • 63
  • You may take a look at [Counter](http://docs.python.org/2/library/collections.html#collections.Counter) – mshsayem Oct 20 '13 at 01:58
  • @mshsayem I know about collections.Counter. How does that apply to this problem? – Shashank Oct 20 '13 at 02:00
  • I think you should add 2 important details. N <= 20 and time limit is 20 seconds. – Abhishek Bansal Oct 20 '13 at 02:19
  • @AbhishekBansal Yes that's true, but I still think the brute force method is too slow. Even for N <= 20, 20! permutations is far too large to handle. I want to find an alternate method to generating all permutations and counting the valid ones. – Shashank Oct 20 '13 at 02:30
  • @ShashankGupta updated my answer. Hope it helps. – Abhishek Bansal Oct 20 '13 at 13:05

3 Answers3

3

I see I solved that one in 2005 - it's still the 10th-fastest there, but uses far less memory than the other accepted solutions. Looking at the code today, I have no idea what it's doing - LOL ;-)

If I recall correctly, this is an instance of "permutations with forbidden positions". That's a search term you can use, along with "rook polynomials". It boils down to computing the "permanent" (another search term) of a 0-1 matrix, and that's a computationally expensive task. That's why you see no accepted Python solutions for this problem on SPOJ (I wrote mine in C).

So, no answers there, but lots of things to research ;-) Getting an accepted program for this one is more about studying the math than about clever programming.

One hint: in my notes I see that I saved a lot of runtime by special-casing input matrices containing all 1's. In that case, the result is simply the factorial of N (for an N-by-N input). Good luck :-)

Spoiler alert!

This shows a relatively easy way of implementing Ryser's formula for a 0-1 matrix. The rows are viewed as ordinary integers, and index subsets are also viewed as ordinary integers. Many micro-optimizations could be added (e.g., if prod becomes 0, break out of the loop early; if the matrix is entirely 1's, return math.factorial(n); etc).

_pc = []
for i in range(256):
    c = 0
    while i:
        # clear last set bit
        i &= i-1
        c += 1
    _pc.append(c)

def popcount(i):
    "Return number of bits set."
    result = 0
    while i:
        result += _pc[i & 0xff]
        i >>= 8
    return result

def perm(a):
    "Return permanent of 0-1 matrix.  Each row is an int."
    result = 0
    n = len(a)
    for s in range(1 << n):
        prod = 1
        for row in a:
            prod *= popcount(row & s)
        if popcount(s) & 1:
            result -= prod
        else:
            result += prod
    if n & 1:
        result = -result
    return result

def matrix2ints(a):
    return [int("".join(map(str, row)), 2)
            for row in a]

def matrix_perm(a):
    "Return permanent of 0-1 matrix."
    return perm(matrix2ints(a))
Tim Peters
  • 67,464
  • 13
  • 126
  • 132
  • 1
    Thanks for the search terms. I'll start looking them up now. Thankfully, I do know a bit of C. Hopefully I can get this working without too much trouble. If this can't be done in Python, then why would they allow Python? Do they just want to troll us? – Shashank Oct 20 '13 at 02:34
  • 1
    SPOJ generally allows you to use any language you like (& that they support). Picking a language fast enough to get the problem solved is part of the fun ;-) – Tim Peters Oct 20 '13 at 03:25
  • I think I'm slowly starting to understand the second version of [Ryser formula in this article](http://en.wikipedia.org/wiki/Computing_the_permanent). It seems fairly easy to transform into code but I just want to check if I have the right idea. Basically you compute the powerset of the set (0,...,n-1) first. Then to calculate each term of the outermost summation, you loop through the powerset PS, and assign each element to S. Take -1^(length(S)) and multiply it by the cumulative product on i from 0 to n-1....(continued) – Shashank Oct 20 '13 at 18:13
  • To calculate each term of the product, loop j through all elements of S and add the element a_ij of the matrix to a sum which will be one term of the outer product term. Multiply all terms together to complete the product and finally multiply the product by -1^length(S) as mentioned above. Is this even close to correct? Also it says if you process the sets in gray code order, you can reduce the complexity to O(2^(n) * n). But I'm not sure what they mean by "process the sets in gray code order". Did you do that in your 2005 code? If so, could you please explain it a bit for me? :) Thanks! – Shashank Oct 20 '13 at 18:14
  • On second thought, I think I get the gray code order thing. o.o Basically it means each successive set processed in the outer summation should only differ by either the inclusion or the exclusion of one element...at least I think. :) But is my idea of the basic formula correct? – Shashank Oct 20 '13 at 18:35
  • Well, details are everything here, so while I *think* you're on the right track, who knows for sure? ;-) I didn't bother with gray code, and I didn't use a matrix (I viewed each row as a plain integer - e.g., the row `[1, 1, 0]` was simply `6` to me). Generating all subsets was just a loop like Python's `for i in xrange(2**N):`. For example, when `N=3`, `i=5` (`0b101`) means "take indices 0 and 2". With clever coding, that can be used with a bitwise `&` to extract the bits of interest. It got complicated, alas :-( With gray code ordering, so many low-level tricks may not be needed. – Tim Peters Oct 20 '13 at 19:01
  • Thanks for the info! Seriously, it's all very helpful. :) I'll try to prototype it later today in Python, and then later translate to C if I get the prototype working. – Shashank Oct 20 '13 at 20:02
  • @ShashankGupta, don't look at my latest edit unless you get stuck! – Tim Peters Oct 21 '13 at 02:59
2

Here is a naive implementation (using the 2nd example matrix):

>>> M = [[1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1], [1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0], [1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0], [1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1], [0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1], [1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1], [1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1], [0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1], [1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1], [1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0]]
>>> L = len(M)
>>> M = [[k for k in xrange(L) if l[k] == 1] for l in M] # Gets the indices of '1's

>>> def count_assignment(taken,row):
       if row >= L: return 1
       c = 0
       for e in M[row]:
          if e not in taken: c = c + count_assignment(taken + [e], row + 1)
       return c

>>> count_assignment([], 0)
7588
mshsayem
  • 17,557
  • 11
  • 61
  • 69
  • This is strangely elegant and efficient. I was thinking of using recursion but I wasn't sure how. Now I feel pretty embarrassed since you happened to do it so easily. – Shashank Oct 20 '13 at 03:07
  • By the way this will be more efficient if you make taken a set instead of a list. Faster membership testing. – Shashank Oct 20 '13 at 03:10
  • It is elegant, but it's not efficient - it will, e.g., take time proportional to `N!` for an N-by-N matrix of 1's. It's great for sparse matrices, though. – Tim Peters Oct 20 '13 at 03:24
  • @TimPeters Yeah I didn't get my answer accepted using this (even after adding a modification with sets and set.union method). I'm currently studying rook polynomials since using combinatorics seems to be the only way to go under the time limit. Still this was a neat way to look at the problem with recursion and that's why I gave this answer +1. – Shashank Oct 20 '13 at 03:36
  • Sure! Just try, e.g., setting `M = [[1] * 11 for i in range(11)]`. Then marvel at how long it takes - LOL ;-) About rook polynomials, they compute more info than you need to solve the problem - you only need the leading term (the coefficient of `x**N`). That will lead you to the "permanent" ;-) – Tim Peters Oct 20 '13 at 03:39
  • 1
    @TimPeters Ugh Linear Algebra...not fun! – Shashank Oct 20 '13 at 03:41
1

The problem is of counting the total number of maximum bipartite matchings in the graph.

Following extract from Wikipedia article may help

The number of matchings in a graph is known as the Hosoya index of the graph. It is #P-complete to compute this quantity. It remains

P-complete in the special case of counting the number of perfect matchings in a given bipartite graph, because computing the permanent

of an arbitrary 0–1 matrix (another #P-complete problem) is the same as computing the number of perfect matchings in the bipartite graph having the given matrix as its biadjacency matrix. However, there exists a fully polynomial time randomized approximation scheme for counting the number of bipartite matchings.[10] A remarkable theorem of Kasteleyn states that the number of perfect matchings in a planar graph can be computed exactly in polynomial time via the FKT algorithm.

The number of perfect matchings in a complete graph Kn (with n even) is given by the double factorial (n − 1)!!.[11] The numbers of matchings in complete graphs, without constraining the matchings to be perfect, are given by the telephone numbers.[12]

Community
  • 1
  • 1
Abhishek Bansal
  • 12,589
  • 4
  • 31
  • 46